Cloud Print Policy - service side enforcement, Mac browser tests.

chrome/browser/printing/cloud_print/test/cloud_print_proxy_process_browsertest.cc

 // Copyright (c) 2012 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.
 
 // Create a service process that uses a Mock to respond to the browser in order
 // to test launching the browser using the cloud print policy check command
 // line switch.
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop.h"
 #include "base/process_util.h"
 #include "base/rand_util.h"
 #include "base/test/multiprocess_test.h"
 #include "base/test/test_timeouts.h"
 #include "base/time.h"
 #include "chrome/browser/printing/cloud_print/cloud_print_proxy_service.h"
 #include "chrome/browser/printing/cloud_print/cloud_print_proxy_service_factory.h"
 #include "chrome/browser/profiles/profile_keyed_service.h"
 #include "chrome/browser/service/service_process_control.h"
 #include "chrome/browser/ui/browser_init.h"
-#include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/service_messages.h"
 #include "chrome/common/service_process_util.h"
 #include "chrome/service/service_ipc_server.h"
 #include "chrome/service/service_process.h"
 #include "chrome/test/base/test_launcher_utils.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_pref_service.h"
 #include "chrome/test/base/testing_profile.h"
 #include "chrome/test/base/testing_profile_manager.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/public/browser/notification_service.h"
 #include "content/test/test_browser_thread.h"
 #include "ipc/ipc_descriptors.h"
 #include "ipc/ipc_switches.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/multiprocess_func_list.h"
 
+#if defined(OS_MACOSX)
+#include "chrome/common/mac/mock_launchd.h"
+#endif
 #if defined(OS_POSIX)
 #include "base/global_descriptors_posix.h"
 #endif
 
 using ::testing::AnyNumber;
 using ::testing::Assign;
 using ::testing::AtLeast;
 using ::testing::DoAll;
 using ::testing::Invoke;
 using ::testing::Mock;
 using ::testing::Property;
 using ::testing::Return;
 using ::testing::WithoutArgs;
 using ::testing::_;
 
 namespace {
 
+enum MockServiceProcessExitCodes {
+  kMissingSwitch = 1,
+  kInitializationFailure,
+  kExpectationsNotMet,
+  kShutdownNotGood
+};
+
+#if defined(OS_MACOSX)
+const char kTestExecutablePath[] = "test-executable-path";
+#endif
+
 bool g_good_shutdown = false;
 
 void ShutdownTask() {
   g_good_shutdown = true;
   g_service_process->Shutdown();
 }
 
 class TestStartupClientChannelListener : public IPC::Channel::Listener {
  public:
   virtual bool OnMessageReceived(const IPC::Message& message) { return false; }
@@ skipping 105 matching lines @@
     info_.enabled = false;
     info_.email = std::string();
     EXPECT_TRUE(Send(new ServiceHostMsg_CloudPrintProxy_Info(info_)));
   }
   return true;
 }
 
 typedef base::Callback<void(MockServiceIPCServer* server)>
     SetExpectationsCallback;
 
+// The return value from this routine is used as the exit code for the mock
+// service process. Any non-zero return value will be printed out and can help
+// determine the failure.
 int CloudPrintMockService_Main(SetExpectationsCallback set_expectations) {
   MessageLoopForUI main_message_loop;
   main_message_loop.set_thread_name("Main Thread");
 
+#if defined(OS_MACOSX)
+  CommandLine* cl = CommandLine::ForCurrentProcess();
+  if (!cl->HasSwitch(kTestExecutablePath))
+    return kMissingSwitch;
+  FilePath executable_path = cl->GetSwitchValuePath(kTestExecutablePath);
+  EXPECT_FALSE(executable_path.empty());
+  MockLaunchd mock_launchd(executable_path, &main_message_loop, true, true);
+  Launchd::ScopedInstance use_mock(&mock_launchd);
+#endif
+
   ServiceProcessState* state(new ServiceProcessState);
-  EXPECT_TRUE(state->Initialize());
+  bool service_process_state_initialized = state->Initialize();
+  EXPECT_TRUE(service_process_state_initialized);
+  if (!service_process_state_initialized)
+    return kInitializationFailure;
 
   TestServiceProcess service_process;
   EXPECT_EQ(&service_process, g_service_process);
 
   // Takes ownership of the pointer, but we can use it since we have the same
   // lifetime.
   EXPECT_TRUE(service_process.Initialize(&main_message_loop, state));
 
   MockServiceIPCServer server(state->GetServiceProcessChannel());
 
   // Here is where the expectations/mock responses need to be set up.
   set_expectations.Run(&server);
 
   EXPECT_TRUE(server.Init());
   EXPECT_TRUE(state->SignalReady(service_process.IOMessageLoopProxy(),
                                  base::Bind(&ShutdownTask)));
+#if defined(OS_MACOSX)
+  mock_launchd.SignalReady();
+#endif
 
   // Connect up the parent/child IPC channel to signal that the test can
   // continue.
   TestStartupClientChannelListener listener;
   EXPECT_TRUE(CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kProcessChannelID));
   std::string startup_channel_name =
       CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
           switches::kProcessChannelID);
   scoped_ptr<IPC::ChannelProxy> startup_channel;
   startup_channel.reset(
       new IPC::ChannelProxy(startup_channel_name,
                             IPC::Channel::MODE_CLIENT,
                             &listener,
                             service_process.IOMessageLoopProxy()));
 
   main_message_loop.Run();
   if (!Mock::VerifyAndClearExpectations(&server))
-    return 1;
+    return kExpectationsNotMet;
   if (!g_good_shutdown)
-    return 2;
+    return kShutdownNotGood;
   return 0;
 }
 
 void SetServiceEnabledExpectations(MockServiceIPCServer* server) {
   server->SetServiceEnabledExpectations();
 }
 
 MULTIPROCESS_TEST_MAIN(CloudPrintMockService_StartEnabledWaitForQuit) {
   return CloudPrintMockService_Main(
       base::Bind(&SetServiceEnabledExpectations));
@@ skipping 40 matching lines @@
   }
 
  protected:
   MessageLoopForUI message_loop_;
   content::TestBrowserThread ui_thread_;
   base::Thread io_thread_;
 
   std::string startup_channel_id_;
   scoped_ptr<IPC::ChannelProxy> startup_channel_;
 
+#if defined(OS_MACOSX)
+  ScopedTempDir temp_dir_;
+  FilePath executable_path_, bundle_path_;
+  scoped_ptr<MockLaunchd> mock_launchd_;
+  scoped_ptr<Launchd::ScopedInstance> scoped_launchd_instance_;
+#endif
+
  private:
   class WindowedChannelConnectionObserver {
    public:
     WindowedChannelConnectionObserver()
         : seen_(false),
           running_(false) { }
 
     void Wait() {
       if (seen_)
         return;
       running_ = true;
       ui_test_utils::RunMessageLoop();
     }
 
     void Notify() {
       seen_ = true;
       if (running_)
         MessageLoopForUI::current()->Quit();
     }
 
    private:
     bool seen_;
     bool running_;
   };
 
   WindowedChannelConnectionObserver observer_;
 };
 
-
 CloudPrintProxyPolicyStartupTest::CloudPrintProxyPolicyStartupTest()
     : ui_thread_(content::BrowserThread::UI, &message_loop_),
       io_thread_("CloudPrintProxyPolicyTestThread") {
 }
 
 CloudPrintProxyPolicyStartupTest::~CloudPrintProxyPolicyStartupTest() {
 }
 
 void CloudPrintProxyPolicyStartupTest::SetUp() {
   base::Thread::Options options(MessageLoop::TYPE_IO, 0);
   ASSERT_TRUE(io_thread_.StartWithOptions(options));
+
+#if defined(OS_MACOSX)
+  EXPECT_TRUE(temp_dir_.CreateUniqueTempDir());
+  EXPECT_TRUE(MockLaunchd::MakeABundle(temp_dir_.path(),
+                                       "CloudPrintProxyTest",
+                                       &bundle_path_,
+                                       &executable_path_));
+  mock_launchd_.reset(new MockLaunchd(executable_path_, &message_loop_,
+                                      true, false));
+  scoped_launchd_instance_.reset(
+      new Launchd::ScopedInstance(mock_launchd_.get()));
+#endif
 }
 
 base::ProcessHandle CloudPrintProxyPolicyStartupTest::Launch(
     const std::string& name) {
   EXPECT_FALSE(CheckServiceProcessReady());
 
   startup_channel_id_ =
       base::StringPrintf("%d.%p.%d",
                          base::GetCurrentProcId(), this,
                          base::RandInt(0, std::numeric_limits<int>::max()));
@@ skipping 42 matching lines @@
 
 void CloudPrintProxyPolicyStartupTest::OnChannelConnected(int32 peer_pid) {
   observer_.Notify();
 }
 
 CommandLine CloudPrintProxyPolicyStartupTest::MakeCmdLine(
     const std::string& procname,
     bool debug_on_start) {
   CommandLine cl = MultiProcessTest::MakeCmdLine(procname, debug_on_start);
   cl.AppendSwitchASCII(switches::kProcessChannelID, startup_channel_id_);
+#if defined(OS_MACOSX)
+  cl.AppendSwitchASCII(kTestExecutablePath, executable_path_.value());
+#endif
   return cl;
 }
 
 TEST_F(CloudPrintProxyPolicyStartupTest, StartAndShutdown) {
   base::ProcessHandle handle =
       Launch("CloudPrintMockService_StartEnabledWaitForQuit");
   WaitForConnect();
   ShutdownAndWaitForExitWithTimeout(handle);
 }
 
@@ skipping 79 matching lines @@
   // No expectations on run_loop being true here; that would be a race
   // condition.
   if (run_loop)
     MessageLoop::current()->Run();
 
   EXPECT_EQ("", prefs->GetString(prefs::kCloudPrintEmail));
 
   ShutdownAndWaitForExitWithTimeout(handle);
   profile_manager.DeleteTestingProfile("StartBrowserWithPolicy");
 }