Modify chrome_frame_net_tests to integrate the refactoring to ProcessSingleton.

chrome_frame/test/net/fake_external_tab.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.
 
 #include "chrome_frame/test/net/fake_external_tab.h"
 
 #include <atlbase.h>
 #include <atlcom.h>
 #include <exdisp.h>
 #include <Winsock2.h>
@@ skipping 33 matching lines @@
 #include "chrome/common/chrome_paths_internal.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/renderer/chrome_content_renderer_client.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "chrome/test/logging/win/file_logger.h"
 #include "chrome/test/logging/win/log_file_printer.h"
 #include "chrome/test/logging/win/test_log_collector.h"
 #include "chrome_frame/crash_server_init.h"
 #include "chrome_frame/test/chrome_frame_test_utils.h"
+#include "chrome_frame/test/ie_configurator.h"
 #include "chrome_frame/test/net/test_automation_resource_message_filter.h"
 #include "chrome_frame/test/simulate_input.h"
 #include "chrome_frame/test/win_event_receiver.h"
 #include "chrome_frame/utils.h"
 #include "content/public/app/content_main.h"
 #include "content/public/app/startup_helper_win.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/content_paths.h"
 #include "net/base/net_util.h"
+#include "net/url_request/url_request_test_util.h"
 #include "sandbox/win/src/sandbox_types.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/ui_base_paths.h"
 
 using content::BrowserThread;
 
 namespace {
 
 // We must store this globally so that our main delegate can set it.
@@ skipping 358 matching lines @@
   if (file_util::PathExists(user_data_dir_)) {
     VLOG(1) << __FUNCTION__ << " deleting IE Profile user data directory "
             << user_data_dir_.value();
     bool deleted = file_util::Delete(user_data_dir_, true);
     LOG_IF(ERROR, !deleted) << "Failed to delete user data directory directory "
                             << user_data_dir_.value();
   }
 
   PathService::Get(chrome::DIR_USER_DATA, &overridden_user_dir_);
   PathService::Override(chrome::DIR_USER_DATA, user_data_dir_);
-  process_singleton_.reset(new ProcessSingleton(user_data_dir_));
 }
 
 FakeExternalTab::~FakeExternalTab() {
   if (!overridden_user_dir_.empty()) {
     PathService::Override(chrome::DIR_USER_DATA, overridden_user_dir_);
   }
 }
 
 void FakeExternalTab::Initialize() {
   DCHECK(g_browser_process == NULL);
@@ skipping 28 matching lines @@
 
 void FakeExternalTab::InitializePostThreadsCreated() {
   FilePath profile_path(ProfileManager::GetDefaultProfileDir(user_data()));
   Profile* profile =
       g_browser_process->profile_manager()->GetProfile(profile_path);
 }
 
 void FakeExternalTab::Shutdown() {
   browser_process_.reset();
   g_browser_process = NULL;
-  process_singleton_.reset();
 
   ResourceBundle::CleanupSharedInstance();
 }
 
 FakeBrowserProcessImpl* FakeExternalTab::browser_process() const {
   return browser_process_.get();
 }
 
 CFUrlRequestUnittestRunner::CFUrlRequestUnittestRunner(int argc, char** argv)
     : NetTestSuite(argc, argv, false),
@@ skipping 81 matching lines @@
   // http://crbug.com/114369 .
   OverrideHttpHost();
 }
 
 void CFUrlRequestUnittestRunner::Shutdown() {
   DCHECK(::GetCurrentThreadId() == test_thread_id_);
   NetTestSuite::Shutdown();
   OleUninitialize();
 }
 
-void CFUrlRequestUnittestRunner::OnConnectAutomationProviderToChannel(
-    const std::string& channel_id) {
-  Profile* profile = g_browser_process->profile_manager()->
-      GetDefaultProfile(fake_chrome_->user_data());
-
-  AutomationProviderList* list = g_browser_process->GetAutomationProviderList();
-  DCHECK(list);
-  list->AddProvider(
-      TestAutomationProvider::NewAutomationProvider(profile, channel_id, this));
-}
-
 void CFUrlRequestUnittestRunner::OnInitialTabLoaded() {
   test_http_server_.reset();
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&CFUrlRequestUnittestRunner::CancelInitializationTimeout,
                  base::Unretained(this)));
   StartTests();
 }
 
@@ skipping 127 matching lines @@
 void CFUrlRequestUnittestRunner::PreEarlyInitialization() {
   testing::InitGoogleTest(&g_argc, g_argv);
   FilterDisabledTests();
   StartFileLogger();
 }
 
 int CFUrlRequestUnittestRunner::PreCreateThreads() {
   fake_chrome_.reset(new FakeExternalTab());
   fake_chrome_->Initialize();
   fake_chrome_->browser_process()->PreCreateThreads();
+  process_singleton_.reset(new ProcessSingleton(fake_chrome_->user_data()));
+  process_singleton_->Lock(NULL);
+  return 0;
+}
 
-  pss_subclass_.reset(new ProcessSingletonSubclass(this));
-  EXPECT_TRUE(pss_subclass_->Subclass(fake_chrome_->user_data()));
-  StartChromeFrameInHostBrowser();
-  return 0;
+bool CFUrlRequestUnittestRunner::ProcessSingletonNotificationCallback(
+    const CommandLine& command_line, const FilePath& current_directory) {
+  std::string channel_id = command_line.GetSwitchValueASCII(
+      switches::kAutomationClientChannelID);
+  EXPECT_FALSE(channel_id.empty());
+
+  Profile* profile = g_browser_process->profile_manager()->GetDefaultProfile(
+      fake_chrome_->user_data());
+
+  AutomationProviderList* list = g_browser_process->GetAutomationProviderList();
+  DCHECK(list);
+  list->AddProvider(
+      TestAutomationProvider::NewAutomationProvider(profile, channel_id, this));
+  return true;
 }
 
 void CFUrlRequestUnittestRunner::PreMainMessageLoopRun() {
   fake_chrome_->InitializePostThreadsCreated();
+  ProcessSingleton::NotificationCallback callback(
+      base::Bind(
+          &CFUrlRequestUnittestRunner::ProcessSingletonNotificationCallback,
+          base::Unretained(this)));
+  if (!process_singleton_->Create(callback)) {
+    LOG(FATAL) << "Failed to start up ProcessSingleton. Is another test "
+               << "executable or Chrome Frame running?";
+    if (crash_service_)
+      base::KillProcess(crash_service_, 0, false);
+    ::ExitProcess(1);
+  }
+
+  StartChromeFrameInHostBrowser();
 }
 
 bool CFUrlRequestUnittestRunner::MainMessageLoopRun(int* result_code) {
   DCHECK(MessageLoop::current());
   DCHECK(MessageLoop::current()->type() == MessageLoop::TYPE_UI);
 
   // We need to allow IO on the main thread for these tests.
   base::ThreadRestrictions::SetIOAllowed(true);
-
+  process_singleton_->Unlock();
   StartInitializationTimeout();
   return false;
 }
 
 void CFUrlRequestUnittestRunner::PostMainMessageLoopRun() {
+  process_singleton_->Cleanup();
   fake_chrome_->browser_process()->StartTearDown();
 
   // Must do this separately as the mock profile_manager_ is not the
   // same member as BrowserProcessImpl::StartTearDown resets.
   fake_chrome_->browser_process()->DestroyProfileManager();
 
   if (crash_service_)
     base::KillProcess(crash_service_, 0, false);
 
   base::KillProcesses(chrome_frame_test::kIEImageName, 0, NULL);
   base::KillProcesses(chrome_frame_test::kIEBrokerImageName, 0, NULL);
 }
 
 void CFUrlRequestUnittestRunner::PostDestroyThreads() {
+  process_singleton_.reset();
   fake_chrome_->browser_process()->PostDestroyThreads();
   fake_chrome_->Shutdown();
   fake_chrome_.reset();
 
 #ifndef NDEBUG
   // Avoid CRT cleanup in debug test runs to ensure that webkit ASSERTs which
   // check if globals are created and destroyed on the same thread don't fire.
   // Webkit global objects are created on the inproc renderer thread.
   ::ExitProcess(test_result());
 #endif
@@ skipping 105 matching lines @@
   // content::InitializeSandboxInfo(&sandbox_info);
   FakeMainDelegate delegate;
   content::ContentMain(
       reinterpret_cast<HINSTANCE>(GetModuleHandle(NULL)),
       &sandbox_info,
       &delegate);
 
   // Note:  In debug builds, we ExitProcess during PostDestroyThreads.
   return g_test_suite->test_result();
 }