// Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "apps/app_shim/app_shim_host_manager_mac.h"

#include <unistd.h>

#include "apps/app_shim/app_shim_messages.h"
#include "apps/app_shim/test/app_shim_host_manager_test_api_mac.h"
#include "base/files/file_path.h"
#include "base/logging.h"
#include "base/path_service.h"
#include "chrome/browser/browser_process.h"
#include "chrome/browser/profiles/profile.h"
#include "chrome/browser/ui/browser.h"
#include "chrome/common/chrome_paths.h"
#include "chrome/common/mac/app_mode_common.h"
#include "chrome/test/base/in_process_browser_test.h"
#include "content/public/test/test_utils.h"
#include "ipc/ipc_channel_proxy.h"
#include "ipc/ipc_listener.h"
#include "ipc/ipc_message.h"

namespace {

const char kTestAppMode[] = "test_app";

// A test version of the AppShimController IPC client in chrome_main_app_mode.
class TestShimClient : public IPC::Listener {
 public:
  TestShimClient(const base::FilePath& socket_path);
  virtual ~TestShimClient();

  template <class T>
  void Send(const T& message) {
    channel_->Send(message);
  }

 private:
  // IPC::Listener overrides:
  virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
  virtual void OnChannelError() OVERRIDE;

  base::Thread io_thread_;
  scoped_ptr<IPC::ChannelProxy> channel_;

  DISALLOW_COPY_AND_ASSIGN(TestShimClient);
};

TestShimClient::TestShimClient(const base::FilePath& socket_path)
    : io_thread_("TestShimClientIO") {
  base::Thread::Options io_thread_options;
  io_thread_options.message_loop_type = base::MessageLoop::TYPE_IO;
  io_thread_.StartWithOptions(io_thread_options);

  IPC::ChannelHandle handle(socket_path.value());
  channel_.reset(new IPC::ChannelProxy(handle, IPC::Channel::MODE_NAMED_CLIENT,
      this, io_thread_.message_loop_proxy().get()));
}

TestShimClient::~TestShimClient() {}

bool TestShimClient::OnMessageReceived(const IPC::Message& message) {
  return true;
}

void TestShimClient::OnChannelError() {
  // Client should not get any channel errors for the current set of tests.
  PLOG(FATAL) << "ChannelError";
}

// Browser Test for AppShimHostManager to test IPC interactions across the
// UNIX domain socket.
class AppShimHostManagerBrowserTest : public InProcessBrowserTest,
                                      public apps::AppShimHandler {
 public:
  AppShimHostManagerBrowserTest();
  virtual ~AppShimHostManagerBrowserTest();

 protected:
  // Wait for OnShimLaunch, then send a quit, and wait for the response. Used to
  // test launch behavior.
  void RunAndExitGracefully();

  // InProcessBrowserTest overrides:
  virtual void SetUpOnMainThread() OVERRIDE;
  virtual void TearDownOnMainThread() OVERRIDE;
  virtual bool SetUpUserDataDirectory() OVERRIDE;

  // AppShimHandler overrides:
  virtual void OnShimLaunch(apps::AppShimHandler::Host* host,
                            apps::AppShimLaunchType launch_type,
                            const std::vector<base::FilePath>& files) OVERRIDE;
  virtual void OnShimClose(apps::AppShimHandler::Host* host) OVERRIDE {}
  virtual void OnShimFocus(apps::AppShimHandler::Host* host,
                           apps::AppShimFocusType focus_type,
                           const std::vector<base::FilePath>& files) OVERRIDE {}
  virtual void OnShimSetHidden(apps::AppShimHandler::Host* host,
                               bool hidden) OVERRIDE {}
  virtual void OnShimQuit(apps::AppShimHandler::Host* host) OVERRIDE;

  scoped_ptr<TestShimClient> test_client_;
  base::FilePath short_socket_path_;
  std::vector<base::FilePath> last_launch_files_;
  apps::AppShimLaunchType last_launch_type_;

private:
  scoped_refptr<content::MessageLoopRunner> runner_;
  base::ScopedTempDir short_temp_dir_;

  int launch_count_;
  int quit_count_;

  DISALLOW_COPY_AND_ASSIGN(AppShimHostManagerBrowserTest);
};

AppShimHostManagerBrowserTest::AppShimHostManagerBrowserTest()
    : last_launch_type_(apps::APP_SHIM_LAUNCH_NUM_TYPES),
      launch_count_(0),
      quit_count_(0) {
}

AppShimHostManagerBrowserTest::~AppShimHostManagerBrowserTest() {
}

void AppShimHostManagerBrowserTest::RunAndExitGracefully() {
  runner_ = new content::MessageLoopRunner();
  EXPECT_EQ(0, launch_count_);
  runner_->Run();  // Will stop in OnShimLaunch().
  EXPECT_EQ(1, launch_count_);

  runner_ = new content::MessageLoopRunner();
  test_client_->Send(new AppShimHostMsg_QuitApp);
  EXPECT_EQ(0, quit_count_);
  runner_->Run();  // Will stop in OnShimQuit().
  EXPECT_EQ(1, quit_count_);

  test_client_.reset();
}

void AppShimHostManagerBrowserTest::SetUpOnMainThread() {
  // Can't do this in the constructor, it needs a BrowserProcess.
  apps::AppShimHandler::RegisterHandler(kTestAppMode, this);
}

void AppShimHostManagerBrowserTest::TearDownOnMainThread() {
  apps::AppShimHandler::RemoveHandler(kTestAppMode);
}

bool AppShimHostManagerBrowserTest::SetUpUserDataDirectory() {
  // Create a symlink at /tmp/scoped_dir_XXXXXX/udd that points to the real user
  // data dir, and use this as the domain socket path. This is required because
  // there is a path length limit for named sockets that is exceeded in
  // multi-process test spawning.
  base::FilePath real_user_data_dir;
  EXPECT_TRUE(PathService::Get(chrome::DIR_USER_DATA, &real_user_data_dir));
  EXPECT_TRUE(
      short_temp_dir_.CreateUniqueTempDirUnderPath(base::FilePath("/tmp")));
  base::FilePath shortened_user_data_dir = short_temp_dir_.path().Append("udd");
  EXPECT_EQ(0, ::symlink(real_user_data_dir.AsUTF8Unsafe().c_str(),
                         shortened_user_data_dir.AsUTF8Unsafe().c_str()));

  test::AppShimHostManagerTestApi::OverrideUserDataDir(shortened_user_data_dir);
  short_socket_path_ =
      shortened_user_data_dir.Append(app_mode::kAppShimSocketName);

  return InProcessBrowserTest::SetUpUserDataDirectory();
}

void AppShimHostManagerBrowserTest::OnShimLaunch(
    apps::AppShimHandler::Host* host,
    apps::AppShimLaunchType launch_type,
    const std::vector<base::FilePath>& files) {
  host->OnAppLaunchComplete(apps::APP_SHIM_LAUNCH_SUCCESS);
  ++launch_count_;
  last_launch_type_ = launch_type;
  last_launch_files_ = files;
  runner_->Quit();
}

void AppShimHostManagerBrowserTest::OnShimQuit(
    apps::AppShimHandler::Host* host) {
  ++quit_count_;
  runner_->Quit();
}

// Test regular launch, which would ask Chrome to launch the app.
IN_PROC_BROWSER_TEST_F(AppShimHostManagerBrowserTest, LaunchNormal) {
  test_client_.reset(new TestShimClient(short_socket_path_));
  test_client_->Send(new AppShimHostMsg_LaunchApp(
      browser()->profile()->GetPath(),
      kTestAppMode,
      apps::APP_SHIM_LAUNCH_NORMAL,
      std::vector<base::FilePath>()));

  RunAndExitGracefully();
  EXPECT_EQ(apps::APP_SHIM_LAUNCH_NORMAL, last_launch_type_);
  EXPECT_TRUE(last_launch_files_.empty());
}

// Test register-only launch, used when Chrome has already launched the app.
IN_PROC_BROWSER_TEST_F(AppShimHostManagerBrowserTest, LaunchRegisterOnly) {
  test_client_.reset(new TestShimClient(short_socket_path_));
  test_client_->Send(new AppShimHostMsg_LaunchApp(
      browser()->profile()->GetPath(),
      kTestAppMode,
      apps::APP_SHIM_LAUNCH_REGISTER_ONLY,
      std::vector<base::FilePath>()));

  RunAndExitGracefully();
  EXPECT_EQ(apps::APP_SHIM_LAUNCH_REGISTER_ONLY, last_launch_type_);
  EXPECT_TRUE(last_launch_files_.empty());
}

// Ensure the domain socket can be created in a fresh user data dir.
IN_PROC_BROWSER_TEST_F(AppShimHostManagerBrowserTest,
                       PRE_ReCreate) {
  test::AppShimHostManagerTestApi test_api(
      g_browser_process->platform_part()->app_shim_host_manager());
  EXPECT_TRUE(test_api.factory());
}

// Ensure the domain socket can be re-created after a prior browser process has
// quit.
IN_PROC_BROWSER_TEST_F(AppShimHostManagerBrowserTest,
                       ReCreate) {
  test::AppShimHostManagerTestApi test_api(
      g_browser_process->platform_part()->app_shim_host_manager());
  EXPECT_TRUE(test_api.factory());
}

// Test for AppShimHostManager that fails to create the socket.
class AppShimHostManagerBrowserTestFailsCreate :
    public AppShimHostManagerBrowserTest {
 public:
  AppShimHostManagerBrowserTestFailsCreate() {}

 private:
  virtual bool SetUpUserDataDirectory() OVERRIDE;

  base::ScopedTempDir barrier_dir_;

  DISALLOW_COPY_AND_ASSIGN(AppShimHostManagerBrowserTestFailsCreate);
};

bool AppShimHostManagerBrowserTestFailsCreate::SetUpUserDataDirectory() {
  base::FilePath user_data_dir;
  // Start in the "real" user data dir for this test. This is a meta-test for
  // the symlinking steps used in the superclass. That is, by putting the
  // clobber in the actual user data dir, the test will fail if the symlink
  // does not actually point to the user data dir, since it won't be clobbered.
  EXPECT_TRUE(PathService::Get(chrome::DIR_USER_DATA, &user_data_dir));
  base::FilePath socket_path =
      user_data_dir.Append(app_mode::kAppShimSocketName);
  // Create a "barrier" to forming the UNIX domain socket. This is just a
  // pre-existing directory which can not be unlink()ed, in order to place a
  // named socked there instead.
  EXPECT_TRUE(barrier_dir_.Set(socket_path));
  return AppShimHostManagerBrowserTest::SetUpUserDataDirectory();
}

// Test error handling. This is essentially testing for lifetime correctness
// during startup for unexpected failures.
IN_PROC_BROWSER_TEST_F(AppShimHostManagerBrowserTestFailsCreate,
                       SocketFailure) {
  test::AppShimHostManagerTestApi test_api(
      g_browser_process->platform_part()->app_shim_host_manager());
  EXPECT_FALSE(test_api.factory());
}

}  // namespace