Do not spawn a thread in browser/interactive ui tests before spawning sandbox host process

chromeos/dbus/dbus_thread_manager.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 "chromeos/dbus/dbus_thread_manager.h"
 
 #include <map>
 
 #include "base/command_line.h"
 #include "base/observer_list.h"
@@ skipping 33 matching lines @@
 #include "chromeos/dbus/shill_stub_helper.h"
 #include "chromeos/dbus/sms_client.h"
 #include "chromeos/dbus/system_clock_client.h"
 #include "chromeos/dbus/update_engine_client.h"
 #include "dbus/bus.h"
 #include "dbus/dbus_statistics.h"
 
 namespace chromeos {
 
 static DBusThreadManager* g_dbus_thread_manager = NULL;
-static bool g_dbus_thread_manager_set_for_testing = false;
+static DBusThreadManager* g_dbus_thread_manager_for_testing = NULL;
 
 // The DBusThreadManager implementation used in production.
 class DBusThreadManagerImpl : public DBusThreadManager {
  public:
   explicit DBusThreadManagerImpl() {
     // Create the D-Bus thread.
     base::Thread::Options thread_options;
     thread_options.message_loop_type = base::MessageLoop::TYPE_IO;
     dbus_thread_.reset(new base::Thread("D-Bus thread"));
     dbus_thread_->StartWithOptions(thread_options);
@@ skipping 247 matching lines @@
   scoped_ptr<PowerManagerClient> power_manager_client_;
   scoped_ptr<SessionManagerClient> session_manager_client_;
   scoped_ptr<SMSClient> sms_client_;
   scoped_ptr<UpdateEngineClient> update_engine_client_;
 
   scoped_ptr<PowerPolicyController> power_policy_controller_;
 };
 
 // static
 void DBusThreadManager::Initialize() {
-  // Ignore Initialize() if we set a test DBusThreadManager.
-  if (g_dbus_thread_manager_set_for_testing)
-    return;
   // If we initialize DBusThreadManager twice we may also be shutting it down
   // early; do not allow that.
   CHECK(g_dbus_thread_manager == NULL);
 
+  if (g_dbus_thread_manager_for_testing) {
+    g_dbus_thread_manager = g_dbus_thread_manager_for_testing;
+    InitializeClients();
+    VLOG(1) << "DBusThreadManager initialized with test implementation";
+    return;
+  }
   // Determine whether we use stub or real client implementations.
   if (base::SysInfo::IsRunningOnChromeOS()) {
     g_dbus_thread_manager = new DBusThreadManagerImpl;
     InitializeClients();
     VLOG(1) << "DBusThreadManager initialized for ChromeOS";
   } else {
     InitializeWithStub();
-    return;
   }
 }
 
 // static
+void DBusThreadManager::SetInstanceForTesting(
+    DBusThreadManager* dbus_thread_manager) {
+  CHECK(!g_dbus_thread_manager);
+  CHECK(!g_dbus_thread_manager_for_testing);
+  g_dbus_thread_manager_for_testing = dbus_thread_manager;
+}
+
+// static
 void DBusThreadManager::InitializeForTesting(
     DBusThreadManager* dbus_thread_manager) {
-  // If we initialize DBusThreadManager twice we may also be shutting it down
-  // early; do not allow that.
-  CHECK(g_dbus_thread_manager == NULL);
-  CHECK(dbus_thread_manager);
-  g_dbus_thread_manager = dbus_thread_manager;
-  g_dbus_thread_manager_set_for_testing = true;
-  InitializeClients();
-  VLOG(1) << "DBusThreadManager initialized with test implementation";
+  SetInstanceForTesting(dbus_thread_manager);
+  Initialize();
 }
 
 // static
 void DBusThreadManager::InitializeWithStub() {
   // If we initialize DBusThreadManager twice we may also be shutting it down
   // early; do not allow that.
   CHECK(g_dbus_thread_manager == NULL);
   FakeDBusThreadManager* fake_dbus_thread_manager = new FakeDBusThreadManager;
   fake_dbus_thread_manager->SetFakeClients();
   g_dbus_thread_manager = fake_dbus_thread_manager;
   InitializeClients();
   shill_stub_helper::SetupDefaultEnvironment();
   VLOG(1) << "DBusThreadManager initialized with stub implementation";
 }
 
 // static
 bool DBusThreadManager::IsInitialized() {
   return g_dbus_thread_manager != NULL;
 }
 
 // static
 void DBusThreadManager::Shutdown() {
   // If we called InitializeForTesting, this may get called more than once.
   // Ensure that we only shutdown DBusThreadManager once.
-  CHECK(g_dbus_thread_manager || g_dbus_thread_manager_set_for_testing);
+  CHECK(g_dbus_thread_manager || g_dbus_thread_manager_for_testing);
   DBusThreadManager* dbus_thread_manager = g_dbus_thread_manager;
   g_dbus_thread_manager = NULL;
+  g_dbus_thread_manager_for_testing = NULL;
   delete dbus_thread_manager;
   VLOG(1) << "DBusThreadManager Shutdown completed";
 }
 
 DBusThreadManager::DBusThreadManager() {
   dbus::statistics::Initialize();
 }
 
 DBusThreadManager::~DBusThreadManager() {
   dbus::statistics::Shutdown();
   if (g_dbus_thread_manager == NULL)
     return;  // Called form Shutdown() or local test instance.
   // There should never be both a global instance and a local instance.
   CHECK(this == g_dbus_thread_manager);
-  if (g_dbus_thread_manager_set_for_testing) {
+  if (g_dbus_thread_manager_for_testing) {
     g_dbus_thread_manager = NULL;
-    g_dbus_thread_manager_set_for_testing = false;
+    g_dbus_thread_manager_for_testing = NULL;
     VLOG(1) << "DBusThreadManager destroyed";
   } else {
     LOG(FATAL) << "~DBusThreadManager() called outside of Shutdown()";
   }
 }
 
 // static
 DBusThreadManager* DBusThreadManager::Get() {
   CHECK(g_dbus_thread_manager)
       << "DBusThreadManager::Get() called before Initialize()";
@@ skipping 45 matching lines @@
     g_dbus_thread_manager->GetSystemBus()->GetManagedObjects();
 }
 
 // static
 void DBusThreadManager::InitClient(DBusClient* client) {
   if (client)
     client->Init(g_dbus_thread_manager->GetSystemBus());
 }
 
 }  // namespace chromeos