Correctly integrate StoragePartition into TestingProfile.

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/message_loop.h"
 #include "base/process_util.h"
 #include "base/rand_util.h"
+#include "base/synchronization/waitable_event.h"
 #include "base/test/multiprocess_test.h"
 #include "base/test/test_timeouts.h"
+#include "base/time/default_tick_clock.h"
 #include "base/time/time.h"
+#include "chrome/browser/prefs/browser_prefs.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/service/service_process_control.h"
 #include "chrome/browser/ui/startup/startup_browser_creator.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_io_thread_state.h"
 #include "chrome/test/base/testing_pref_service_syncable.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 "components/browser_context_keyed_service/browser_context_keyed_service.h"
 #include "content/public/browser/notification_service.h"
-#include "content/public/test/test_browser_thread.h"
+#include "content/public/test/test_browser_thread_bundle.h"
 #include "ipc/ipc_descriptors.h"
 #include "ipc/ipc_multiprocess_test.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/posix/global_descriptors.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::_;
+using content::BrowserThread;
 
 namespace {
 
 enum MockServiceProcessExitCodes {
   kMissingSwitch = 1,
   kInitializationFailure,
   kExpectationsNotMet,
   kShutdownNotGood
 };
 
@@ skipping 128 matching lines @@
 
 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) {
   base::MessageLoopForUI main_message_loop;
   main_message_loop.set_thread_name("Main Thread");
+  CommandLine* command_line = CommandLine::ForCurrentProcess();
 
 #if defined(OS_MACOSX)
-  CommandLine* cl = CommandLine::ForCurrentProcess();
-  if (!cl->HasSwitch(kTestExecutablePath))
+  if (!command_line->HasSwitch(kTestExecutablePath))
     return kMissingSwitch;
-  base::FilePath executable_path = cl->GetSwitchValuePath(kTestExecutablePath);
+  base::FilePath executable_path =
+      command_line->GetSwitchValuePath(kTestExecutablePath);
   EXPECT_FALSE(executable_path.empty());
   MockLaunchd mock_launchd(executable_path, &main_message_loop, true, true);
   Launchd::ScopedInstance use_mock(&mock_launchd);
 #endif
 
+  base::FilePath user_data_dir =
+      command_line->GetSwitchValuePath(switches::kUserDataDir);
+  CHECK(!user_data_dir.empty());
+  CHECK(test_launcher_utils::OverrideUserDataDir(user_data_dir));
+
   ServiceProcessState* state(new ServiceProcessState);
   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
@@ skipping 53 matching lines @@
       base::Bind(&SetServiceWillBeDisabledExpectations));
 }
 
 class CloudPrintProxyPolicyStartupTest : public base::MultiProcessTest,
                                          public IPC::Listener {
  public:
   CloudPrintProxyPolicyStartupTest();
   virtual ~CloudPrintProxyPolicyStartupTest();
 
   virtual void SetUp();
-  base::MessageLoopProxy* IOMessageLoopProxy() {
-    return io_thread_.message_loop_proxy().get();
+  scoped_refptr<base::MessageLoopProxy> IOMessageLoopProxy() {
+    return BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO);
   }
   base::ProcessHandle Launch(const std::string& name);
   void WaitForConnect();
   bool Send(IPC::Message* message);
   void ShutdownAndWaitForExitWithTimeout(base::ProcessHandle handle);
 
   // IPC::Listener implementation
   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE {
     return false;
   }
   virtual void OnChannelConnected(int32 peer_pid) OVERRIDE;
 
   // MultiProcessTest implementation.
   virtual CommandLine MakeCmdLine(const std::string& procname,
                                   bool debug_on_start) OVERRIDE;
 
   bool LaunchBrowser(const CommandLine& command_line, Profile* profile) {
     int return_code = 0;
     StartupBrowserCreator browser_creator;
     return StartupBrowserCreator::ProcessCmdLineImpl(
         command_line, base::FilePath(), false, profile,
         StartupBrowserCreator::Profiles(), &return_code, &browser_creator);
   }
 
  protected:
-  base::MessageLoopForUI message_loop_;
-  content::TestBrowserThread ui_thread_;
-  base::Thread io_thread_;
+  content::TestBrowserThreadBundle thread_bundle_;
+  base::ScopedTempDir temp_user_data_dir_;
 
   std::string startup_channel_id_;
   scoped_ptr<IPC::ChannelProxy> startup_channel_;
 
 #if defined(OS_MACOSX)
   base::ScopedTempDir temp_dir_;
   base::FilePath executable_path_, bundle_path_;
   scoped_ptr<MockLaunchd> mock_launchd_;
   scoped_ptr<Launchd::ScopedInstance> scoped_launchd_instance_;
 #endif
@@ skipping 20 matching lines @@
 
    private:
     bool seen_;
     bool running_;
   };
 
   WindowedChannelConnectionObserver observer_;
 };
 
 CloudPrintProxyPolicyStartupTest::CloudPrintProxyPolicyStartupTest()
-    : ui_thread_(content::BrowserThread::UI, &message_loop_),
-      io_thread_("CloudPrintProxyPolicyTestThread") {
+    : thread_bundle_(content::TestBrowserThreadBundle::REAL_IO_THREAD) {
 }
 
 CloudPrintProxyPolicyStartupTest::~CloudPrintProxyPolicyStartupTest() {
 }
 
 void CloudPrintProxyPolicyStartupTest::SetUp() {
-  base::Thread::Options options(base::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_,
+  mock_launchd_.reset(new MockLaunchd(executable_path_,
+                                      base::MessageLoopForUI::current(),
                                       true, false));
   scoped_launchd_instance_.reset(
       new Launchd::ScopedInstance(mock_launchd_.get()));
 #endif
+
+  // Ensure test does not use the standard profile directory. This is copied
+  // from InProcessBrowserTest::SetUp(). These tests require a more complex
+  // process startup so they are unable to just inherit from
+  // InProcessBrowserTest.
+  CommandLine* command_line = CommandLine::ForCurrentProcess();
+  base::FilePath user_data_dir =
+      command_line->GetSwitchValuePath(switches::kUserDataDir);
+  if (user_data_dir.empty()) {
+    ASSERT_TRUE(temp_user_data_dir_.CreateUniqueTempDir() &&
+                temp_user_data_dir_.IsValid())
+        << "Could not create temporary user data directory \""
+        << temp_user_data_dir_.path().value() << "\".";
+
+    user_data_dir = temp_user_data_dir_.path();
+    command_line->AppendSwitchPath(switches::kUserDataDir, user_data_dir);
+  }
+  ASSERT_TRUE(test_launcher_utils::OverrideUserDataDir(user_data_dir));
 }
 
 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 51 matching lines @@
     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) {
+  TestingBrowserProcess* browser_process =
+      TestingBrowserProcess::GetGlobal();
+  TestingProfileManager profile_manager(browser_process);
+  ASSERT_TRUE(profile_manager.SetUp());
+
+  // Must be created after the TestingProfileManager since that creates the
+  // LocalState for the BrowserProcess.  Must be created before profiles are
+  // constructed.
+  chrome::TestingIOThreadState testing_io_thread_state;
+
   base::ProcessHandle handle =
       Launch("CloudPrintMockService_StartEnabledWaitForQuit");
   WaitForConnect();
   ShutdownAndWaitForExitWithTimeout(handle);
+  content::RunAllPendingInMessageLoop();
 }
 
 BrowserContextKeyedService* CloudPrintProxyServiceFactoryForPolicyTest(
     content::BrowserContext* profile) {
   CloudPrintProxyService* service =
       new CloudPrintProxyService(static_cast<Profile*>(profile));
   service->Initialize();
   return service;
 }
 
 TEST_F(CloudPrintProxyPolicyStartupTest, StartBrowserWithoutPolicy) {
   base::ProcessHandle handle =
       Launch("CloudPrintMockService_StartEnabledWaitForQuit");
 
+  // Setup the Browser Process with a full IOThread::Globals.
   TestingBrowserProcess* browser_process =
       TestingBrowserProcess::GetGlobal();
+
   TestingProfileManager profile_manager(browser_process);
   ASSERT_TRUE(profile_manager.SetUp());
 
+  // Must be created after the TestingProfileManager since that creates the
+  // LocalState for the BrowserProcess.  Must be created before profiles are
+  // constructed.
+  chrome::TestingIOThreadState testing_io_thread_state;
+
   TestingProfile* profile =
       profile_manager.CreateTestingProfile("StartBrowserWithoutPolicy");
   CloudPrintProxyServiceFactory::GetInstance()->
       SetTestingFactory(profile, CloudPrintProxyServiceFactoryForPolicyTest);
 
   TestingPrefServiceSyncable* prefs = profile->GetTestingPrefService();
   prefs->SetUserPref(prefs::kCloudPrintEmail,
                      Value::CreateStringValue(
                          MockServiceIPCServer::EnabledUserId()));
 
   CommandLine command_line(CommandLine::NO_PROGRAM);
   command_line.AppendSwitch(switches::kCheckCloudPrintConnectorPolicy);
   test_launcher_utils::PrepareBrowserCommandLineForTests(&command_line);
 
   WaitForConnect();
+  base::RunLoop run_loop;
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
-      base::MessageLoop::QuitClosure(),
+      run_loop.QuitClosure(),
       TestTimeouts::action_timeout());
 
-  bool run_loop = LaunchBrowser(command_line, profile);
-  EXPECT_FALSE(run_loop);
-  if (run_loop)
-    base::MessageLoop::current()->Run();
+  bool should_run_loop = LaunchBrowser(command_line, profile);
+  EXPECT_FALSE(should_run_loop);
+  if (should_run_loop)
+    run_loop.Run();
 
   EXPECT_EQ(MockServiceIPCServer::EnabledUserId(),
             prefs->GetString(prefs::kCloudPrintEmail));
 
   ShutdownAndWaitForExitWithTimeout(handle);
+  content::RunAllPendingInMessageLoop();
   profile_manager.DeleteTestingProfile("StartBrowserWithoutPolicy");
 }
 
 TEST_F(CloudPrintProxyPolicyStartupTest, StartBrowserWithPolicy) {
   base::ProcessHandle handle =
       Launch("CloudPrintMockService_StartEnabledExpectDisabled");
 
   TestingBrowserProcess* browser_process =
       TestingBrowserProcess::GetGlobal();
   TestingProfileManager profile_manager(browser_process);
   ASSERT_TRUE(profile_manager.SetUp());
 
+  // Must be created after the TestingProfileManager since that creates the
+  // LocalState for the BrowserProcess.  Must be created before profiles are
+  // constructed.
+  chrome::TestingIOThreadState testing_io_thread_state;
+
   TestingProfile* profile =
       profile_manager.CreateTestingProfile("StartBrowserWithPolicy");
   CloudPrintProxyServiceFactory::GetInstance()->
       SetTestingFactory(profile, CloudPrintProxyServiceFactoryForPolicyTest);
 
   TestingPrefServiceSyncable* prefs = profile->GetTestingPrefService();
   prefs->SetUserPref(prefs::kCloudPrintEmail,
                      Value::CreateStringValue(
                          MockServiceIPCServer::EnabledUserId()));
   prefs->SetManagedPref(prefs::kCloudPrintProxyEnabled,
                         Value::CreateBooleanValue(false));
 
   CommandLine command_line(CommandLine::NO_PROGRAM);
   command_line.AppendSwitch(switches::kCheckCloudPrintConnectorPolicy);
   test_launcher_utils::PrepareBrowserCommandLineForTests(&command_line);
 
   WaitForConnect();
+  base::RunLoop run_loop;
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
-      base::MessageLoop::QuitClosure(),
+      run_loop.QuitClosure(),
       TestTimeouts::action_timeout());
 
-  bool run_loop = LaunchBrowser(command_line, profile);
+  bool should_run_loop = LaunchBrowser(command_line, profile);
 
   // No expectations on run_loop being true here; that would be a race
   // condition.
-  if (run_loop)
-    base::MessageLoop::current()->Run();
+  if (should_run_loop)
+    run_loop.Run();
 
   EXPECT_EQ("", prefs->GetString(prefs::kCloudPrintEmail));
 
   ShutdownAndWaitForExitWithTimeout(handle);
+  content::RunAllPendingInMessageLoop();
   profile_manager.DeleteTestingProfile("StartBrowserWithPolicy");
 }