Prevent double DBusThreadManager initialization.

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 <utility>
 
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
@@ skipping 23 matching lines @@
 #include "chromeos/dbus/shill_service_client.h"
 #include "chromeos/dbus/shill_third_party_vpn_driver_client.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 DBusThreadManager* g_dbus_thread_manager = nullptr;
 static bool g_using_dbus_thread_manager_for_testing = false;
 
 DBusThreadManager::DBusThreadManager(ProcessMask process_mask,
                                      bool use_real_clients)
     : use_real_clients_(use_real_clients),
       clients_common_(new DBusClientsCommon(use_real_clients)) {
   if (process_mask & PROCESS_BROWSER)
     clients_browser_.reset(new DBusClientsBrowser(use_real_clients));
   // NOTE: When there are clients only used by ash, create them here.
 
@@ skipping 28 matching lines @@
   // Stop the D-Bus thread.
   if (dbus_thread_)
     dbus_thread_->Stop();
 
   dbus::statistics::Shutdown();
 
   if (!g_dbus_thread_manager)
     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);
+  CHECK_EQ(this, g_dbus_thread_manager);
   if (g_using_dbus_thread_manager_for_testing) {
-    g_dbus_thread_manager = NULL;
+    g_dbus_thread_manager = nullptr;
     g_using_dbus_thread_manager_for_testing = false;
     VLOG(1) << "DBusThreadManager destroyed";
   } else {
     LOG(FATAL) << "~DBusThreadManager() called outside of Shutdown()";
   }
 }
 
 dbus::Bus* DBusThreadManager::GetSystemBus() {
   return system_bus_.get();
 }
@@ skipping 129 matching lines @@
 // static
 void DBusThreadManager::Initialize() {
   Initialize(PROCESS_ALL);
 }
 
 // static
 std::unique_ptr<DBusThreadManagerSetter>
 DBusThreadManager::GetSetterForTesting() {
   if (!g_using_dbus_thread_manager_for_testing) {
     g_using_dbus_thread_manager_for_testing = true;
+    CHECK(!g_dbus_thread_manager);
     // TODO(jamescook): Don't initialize clients as a side-effect of using a
     // test API. For now, assume the caller wants all clients.
     g_dbus_thread_manager =
         new DBusThreadManager(PROCESS_ALL, false /* use_real_clients */);
     g_dbus_thread_manager->InitializeClients();
   }
 
   return base::WrapUnique(new DBusThreadManagerSetter());
 }
 
 // static
 bool DBusThreadManager::IsInitialized() {
-  return g_dbus_thread_manager != NULL;
+  return !!g_dbus_thread_manager;
 }
 
 // static
 void DBusThreadManager::Shutdown() {
   // Ensure that we only shutdown DBusThreadManager once.
   CHECK(g_dbus_thread_manager);
   DBusThreadManager* dbus_thread_manager = g_dbus_thread_manager;
-  g_dbus_thread_manager = NULL;
+  g_dbus_thread_manager = nullptr;
   g_using_dbus_thread_manager_for_testing = false;
   delete dbus_thread_manager;
   VLOG(1) << "DBusThreadManager Shutdown completed";
 }
 
 // static
 DBusThreadManager* DBusThreadManager::Get() {
   CHECK(g_dbus_thread_manager)
       << "DBusThreadManager::Get() called before Initialize()";
   return g_dbus_thread_manager;
@@ skipping 88 matching lines @@
       std::move(client);
 }
 
 void DBusThreadManagerSetter::SetUpdateEngineClient(
     std::unique_ptr<UpdateEngineClient> client) {
   DBusThreadManager::Get()->clients_common_->update_engine_client_ =
       std::move(client);
 }
 
 }  // namespace chromeos