Run ContentMain in a browser_test's browser process. This removes duplication of code in the browse…

chrome/test/base/in_process_browser_test.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/test/base/in_process_browser_test.h"
 
 #include "base/auto_reset.h"
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 57 matching lines @@
 
 #if !defined(OS_ANDROID) && !defined(OS_IOS)
 #include "components/storage_monitor/test_storage_monitor.h"
 #endif
 
 namespace {
 
 // Passed as value of kTestType.
 const char kBrowserTestType[] = "browser";
 
-// Used when running in single-process mode.
-base::LazyInstance<ChromeContentRendererClient>::Leaky
-    g_chrome_content_renderer_client = LAZY_INSTANCE_INITIALIZER;
-
 // A BrowserListObserver that makes sure that all browsers created are on the
 // |allowed_desktop_|.
 class SingleDesktopTestObserver : public chrome::BrowserListObserver,
                                   public base::NonThreadSafe {
  public:
   explicit SingleDesktopTestObserver(chrome::HostDesktopType allowed_desktop);
   virtual ~SingleDesktopTestObserver();
 
   // chrome::BrowserListObserver:
   virtual void OnBrowserAdded(Browser* browser) OVERRIDE;
@@ skipping 34 matching lines @@
   // Before we run the browser, we have to hack the path to the exe to match
   // what it would be if Chrome was running, because it is used to fork renderer
   // processes, on Linux at least (failure to do so will cause a browser_test to
   // be run instead of a renderer).
   base::FilePath chrome_path;
   CHECK(PathService::Get(base::FILE_EXE, &chrome_path));
   chrome_path = chrome_path.DirName();
   chrome_path = chrome_path.Append(chrome::kBrowserProcessExecutablePath);
   CHECK(PathService::Override(base::FILE_EXE, chrome_path));
 #endif  // defined(OS_MACOSX)
+
   CreateTestServer(base::FilePath(FILE_PATH_LITERAL("chrome/test/data")));
   base::FilePath src_dir;
   CHECK(PathService::Get(base::DIR_SOURCE_ROOT, &src_dir));
-  embedded_test_server()->ServeFilesFromDirectory(
-      src_dir.AppendASCII("chrome/test/data"));
+  base::FilePath test_data_dir = src_dir.AppendASCII("chrome/test/data");
+  embedded_test_server()->ServeFilesFromDirectory(test_data_dir);
+
+  // chrome::DIR_TEST_DATA isn't going to be setup until after we call
+  // ContentMain. However that is after tests' constructors or SetUp methods,
+  // which sometimes need it. So just override it.
+  CHECK(PathService::Override(chrome::DIR_TEST_DATA, test_data_dir));
 }
 
 InProcessBrowserTest::~InProcessBrowserTest() {
 }
 
 void InProcessBrowserTest::SetUp() {
   // Browser tests will create their own g_browser_process later.
   DCHECK(!g_browser_process);
 
   CommandLine* command_line = CommandLine::ForCurrentProcess();
   // Allow subclasses to change the command line before running any tests.
   SetUpCommandLine(command_line);
   // Add command line arguments that are used by all InProcessBrowserTests.
   PrepareTestCommandLine(command_line);
 
   // Create a temporary user data directory if required.
   ASSERT_TRUE(CreateUserDataDirectory())
       << "Could not create user data directory.";
 
   // Allow subclasses the opportunity to make changes to the default user data
   // dir before running any tests.
   ASSERT_TRUE(SetUpUserDataDirectory())
       << "Could not set up user data directory.";
 
-  // Single-process mode is not set in BrowserMain, so process it explicitly,
-  // and set up renderer.
-  if (command_line->HasSwitch(switches::kSingleProcess)) {
-    content::SetRendererClientForTesting(
-        g_chrome_content_renderer_client.Pointer());
-  }
-
 #if defined(OS_CHROMEOS)
   // Make sure that the log directory exists.
   base::FilePath log_dir = logging::GetSessionLogFile(*command_line).DirName();
   base::CreateDirectory(log_dir);
 #endif  // defined(OS_CHROMEOS)
 
 #if defined(OS_MACOSX)
-  // On Mac, without the following autorelease pool, code which is directly
-  // executed (as opposed to executed inside a message loop) would autorelease
-  // objects into a higher-level pool. This pool is not recycled in-sync with
-  // the message loops' pools and causes problems with code relying on
-  // deallocation via an autorelease pool (such as browser window closure and
-  // browser shutdown). To avoid this, the following pool is recycled after each
-  // time code is directly executed.
-  autorelease_pool_ = new base::mac::ScopedNSAutoreleasePool;
-
   // Always use the MockKeychain if OS encription is used (which is when
   // anything sensitive gets stored, including Cookies).  Without this,
   // many tests will hang waiting for a user to approve KeyChain access.
   OSCrypt::UseMockKeychain(true);
 #endif
 
 #if defined(ENABLE_CAPTIVE_PORTAL_DETECTION)
   captive_portal::CaptivePortalService::set_state_for_testing(
       captive_portal::CaptivePortalService::DISABLED_FOR_TESTING);
 #endif
@@ skipping 177 matching lines @@
     new_command_line.AppendSwitchNative((*iter).first, (*iter).second);
   }
   return new_command_line;
 }
 #endif
 
 void InProcessBrowserTest::RunTestOnMainThreadLoop() {
   // Pump startup related events.
   content::RunAllPendingInMessageLoop();
 
-#if defined(OS_MACOSX)
-  autorelease_pool_->Recycle();
-#endif
-
   chrome::HostDesktopType active_desktop = chrome::GetActiveDesktop();
   // Self-adds/removes itself from the BrowserList observers.
   scoped_ptr<SingleDesktopTestObserver> single_desktop_test_observer;
   if (!multi_desktop_test_) {
     single_desktop_test_observer.reset(
         new SingleDesktopTestObserver(active_desktop));
   }
 
   const BrowserList* active_browser_list =
       BrowserList::GetInstance(active_desktop);
   if (!active_browser_list->empty()) {
     browser_ = active_browser_list->get(0);
 #if defined(USE_ASH)
     // There are cases where windows get created maximized by default.
     if (browser_->window()->IsMaximized())
       browser_->window()->Restore();
 #endif
     content::WaitForLoadStop(
         browser_->tab_strip_model()->GetActiveWebContents());
   }
 
 #if !defined(OS_ANDROID) && !defined(OS_IOS)
   // Do not use the real StorageMonitor for tests, which introduces another
   // source of variability and potential slowness.
   ASSERT_TRUE(storage_monitor::TestStorageMonitor::CreateForBrowserTests());
 #endif
 
+#if defined(OS_MACOSX)
+  // On Mac, without the following autorelease pool, code which is directly
+  // executed (as opposed to executed inside a message loop) would autorelease
+  // objects into a higher-level pool. This pool is not recycled in-sync with
+  // the message loops' pools and causes problems with code relying on
+  // deallocation via an autorelease pool (such as browser window closure and
+  // browser shutdown). To avoid this, the following pool is recycled after each
+  // time code is directly executed.
+  autorelease_pool_ = new base::mac::ScopedNSAutoreleasePool;
+#endif
+
   // Pump any pending events that were created as a result of creating a
   // browser.
   content::RunAllPendingInMessageLoop();
 
   SetUpOnMainThread();
 #if defined(OS_MACOSX)
   autorelease_pool_->Recycle();
 #endif
 
   if (!HasFatalFailure())
@@ skipping 45 matching lines @@
   // On the Mac, this eventually reaches
   // -[BrowserWindowController windowWillClose:], which will post a deferred
   // -autorelease on itself to ultimately destroy the Browser object. The line
   // below is necessary to pump these pending messages to ensure all Browsers
   // get deleted.
   content::RunAllPendingInMessageLoop();
   delete autorelease_pool_;
   autorelease_pool_ = NULL;
 #endif
 }