1// Copyright (c) 2012 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "chromeos/dbus/dbus_thread_manager.h"
6
7#include <map>
8
9#include "base/command_line.h"
10#include "base/observer_list.h"
11#include "base/sys_info.h"
12#include "base/threading/thread.h"
13#include "chromeos/chromeos_switches.h"
14#include "chromeos/dbus/bluetooth_adapter_client.h"
15#include "chromeos/dbus/bluetooth_agent_manager_client.h"
16#include "chromeos/dbus/bluetooth_device_client.h"
17#include "chromeos/dbus/bluetooth_gatt_characteristic_client.h"
18#include "chromeos/dbus/bluetooth_gatt_descriptor_client.h"
19#include "chromeos/dbus/bluetooth_gatt_manager_client.h"
20#include "chromeos/dbus/bluetooth_gatt_service_client.h"
21#include "chromeos/dbus/bluetooth_input_client.h"
22#include "chromeos/dbus/bluetooth_profile_manager_client.h"
23#include "chromeos/dbus/cras_audio_client.h"
24#include "chromeos/dbus/cros_disks_client.h"
25#include "chromeos/dbus/cryptohome_client.h"
26#include "chromeos/dbus/dbus_client.h"
27#include "chromeos/dbus/dbus_thread_manager_observer.h"
28#include "chromeos/dbus/debug_daemon_client.h"
29#include "chromeos/dbus/fake_dbus_thread_manager.h"
30#include "chromeos/dbus/gsm_sms_client.h"
31#include "chromeos/dbus/image_burner_client.h"
32#include "chromeos/dbus/introspectable_client.h"
33#include "chromeos/dbus/lorgnette_manager_client.h"
34#include "chromeos/dbus/modem_messaging_client.h"
35#include "chromeos/dbus/nfc_adapter_client.h"
36#include "chromeos/dbus/nfc_device_client.h"
37#include "chromeos/dbus/nfc_manager_client.h"
38#include "chromeos/dbus/nfc_record_client.h"
39#include "chromeos/dbus/nfc_tag_client.h"
40#include "chromeos/dbus/permission_broker_client.h"
41#include "chromeos/dbus/power_manager_client.h"
42#include "chromeos/dbus/power_policy_controller.h"
43#include "chromeos/dbus/session_manager_client.h"
44#include "chromeos/dbus/shill_device_client.h"
45#include "chromeos/dbus/shill_ipconfig_client.h"
46#include "chromeos/dbus/shill_manager_client.h"
47#include "chromeos/dbus/shill_profile_client.h"
48#include "chromeos/dbus/shill_service_client.h"
49#include "chromeos/dbus/sms_client.h"
50#include "chromeos/dbus/system_clock_client.h"
51#include "chromeos/dbus/update_engine_client.h"
52#include "dbus/bus.h"
53#include "dbus/dbus_statistics.h"
54
55namespace chromeos {
56
57static DBusThreadManager* g_dbus_thread_manager = NULL;
58static DBusThreadManager* g_dbus_thread_manager_for_testing = NULL;
59
60// The bundle of all D-Bus clients used in DBusThreadManagerImpl. The bundle
61// is used to delete them at once in the right order before shutting down the
62// system bus. See also the comment in the destructor of DBusThreadManagerImpl.
63class DBusClientBundle {
64 public:
65  DBusClientBundle() {
66    const DBusClientImplementationType type = REAL_DBUS_CLIENT_IMPLEMENTATION;
67
68    bluetooth_adapter_client_.reset(BluetoothAdapterClient::Create());
69    bluetooth_agent_manager_client_.reset(
70        BluetoothAgentManagerClient::Create());
71    bluetooth_device_client_.reset(BluetoothDeviceClient::Create());
72    bluetooth_gatt_characteristic_client_.reset(
73        BluetoothGattCharacteristicClient::Create());
74    bluetooth_gatt_descriptor_client_.reset(
75        BluetoothGattDescriptorClient::Create());
76    bluetooth_gatt_manager_client_.reset(BluetoothGattManagerClient::Create());
77    bluetooth_gatt_service_client_.reset(BluetoothGattServiceClient::Create());
78    bluetooth_input_client_.reset(BluetoothInputClient::Create());
79    bluetooth_profile_manager_client_.reset(
80        BluetoothProfileManagerClient::Create());
81    cras_audio_client_.reset(CrasAudioClient::Create());
82    cros_disks_client_.reset(CrosDisksClient::Create(type));
83    cryptohome_client_.reset(CryptohomeClient::Create());
84    debug_daemon_client_.reset(DebugDaemonClient::Create());
85    lorgnette_manager_client_.reset(LorgnetteManagerClient::Create());
86    shill_manager_client_.reset(ShillManagerClient::Create());
87    shill_device_client_.reset(ShillDeviceClient::Create());
88    shill_ipconfig_client_.reset(ShillIPConfigClient::Create());
89    shill_service_client_.reset(ShillServiceClient::Create());
90    shill_profile_client_.reset(ShillProfileClient::Create());
91    gsm_sms_client_.reset(GsmSMSClient::Create());
92    image_burner_client_.reset(ImageBurnerClient::Create());
93    introspectable_client_.reset(IntrospectableClient::Create());
94    modem_messaging_client_.reset(ModemMessagingClient::Create());
95    // Create the NFC clients in the correct order based on their dependencies.
96    nfc_manager_client_.reset(NfcManagerClient::Create());
97    nfc_adapter_client_.reset(
98        NfcAdapterClient::Create(nfc_manager_client_.get()));
99    nfc_device_client_.reset(
100        NfcDeviceClient::Create(nfc_adapter_client_.get()));
101    nfc_tag_client_.reset(NfcTagClient::Create(nfc_adapter_client_.get()));
102    nfc_record_client_.reset(NfcRecordClient::Create(nfc_device_client_.get(),
103                                                    nfc_tag_client_.get()));
104    permission_broker_client_.reset(PermissionBrokerClient::Create());
105    power_manager_client_.reset(PowerManagerClient::Create(type));
106    session_manager_client_.reset(SessionManagerClient::Create(type));
107    sms_client_.reset(SMSClient::Create());
108    system_clock_client_.reset(SystemClockClient::Create());
109    update_engine_client_.reset(UpdateEngineClient::Create(type));
110  }
111
112  BluetoothAdapterClient* bluetooth_adapter_client() {
113    return bluetooth_adapter_client_.get();
114  }
115  BluetoothAgentManagerClient* bluetooth_agent_manager_client() {
116    return bluetooth_agent_manager_client_.get();
117  }
118  BluetoothDeviceClient* bluetooth_device_client() {
119    return bluetooth_device_client_.get();
120  }
121  BluetoothGattCharacteristicClient* bluetooth_gatt_characteristic_client() {
122    return bluetooth_gatt_characteristic_client_.get();
123  }
124  BluetoothGattDescriptorClient* bluetooth_gatt_descriptor_client() {
125    return bluetooth_gatt_descriptor_client_.get();
126  }
127  BluetoothGattManagerClient* bluetooth_gatt_manager_client() {
128    return bluetooth_gatt_manager_client_.get();
129  }
130  BluetoothGattServiceClient* bluetooth_gatt_service_client() {
131    return bluetooth_gatt_service_client_.get();
132  }
133  BluetoothInputClient* bluetooth_input_client() {
134    return bluetooth_input_client_.get();
135  }
136  BluetoothProfileManagerClient* bluetooth_profile_manager_client() {
137    return bluetooth_profile_manager_client_.get();
138  }
139  CrasAudioClient* cras_audio_client() {
140    return cras_audio_client_.get();
141  }
142  CrosDisksClient* cros_disks_client() {
143    return cros_disks_client_.get();
144  }
145  CryptohomeClient* cryptohome_client() {
146    return cryptohome_client_.get();
147  }
148  DebugDaemonClient* debug_daemon_client() {
149    return debug_daemon_client_.get();
150  }
151  LorgnetteManagerClient* lorgnette_manager_client() {
152    return lorgnette_manager_client_.get();
153  }
154  ShillDeviceClient* shill_device_client() {
155    return shill_device_client_.get();
156  }
157  ShillIPConfigClient* shill_ipconfig_client() {
158    return shill_ipconfig_client_.get();
159  }
160  ShillManagerClient* shill_manager_client() {
161    return shill_manager_client_.get();
162  }
163  ShillServiceClient* shill_service_client() {
164    return shill_service_client_.get();
165  }
166  ShillProfileClient* shill_profile_client() {
167    return shill_profile_client_.get();
168  }
169  GsmSMSClient* gsm_sms_client() {
170    return gsm_sms_client_.get();
171  }
172  ImageBurnerClient* image_burner_client() {
173    return image_burner_client_.get();
174  }
175  IntrospectableClient* introspectable_client() {
176    return introspectable_client_.get();
177  }
178  ModemMessagingClient* modem_messaging_client() {
179    return modem_messaging_client_.get();
180  }
181  NfcManagerClient* nfc_manager_client() {
182    return nfc_manager_client_.get();
183  }
184  NfcAdapterClient* nfc_adapter_client() {
185    return nfc_adapter_client_.get();
186  }
187  NfcDeviceClient* nfc_device_client() {
188    return nfc_device_client_.get();
189  }
190  NfcTagClient* nfc_tag_client() {
191    return nfc_tag_client_.get();
192  }
193  NfcRecordClient* nfc_record_client() {
194    return nfc_record_client_.get();
195  }
196  PermissionBrokerClient* permission_broker_client() {
197    return permission_broker_client_.get();
198  }
199  SystemClockClient* system_clock_client() {
200    return system_clock_client_.get();
201  }
202  PowerManagerClient* power_manager_client() {
203    return power_manager_client_.get();
204  }
205  SessionManagerClient* session_manager_client() {
206    return session_manager_client_.get();
207  }
208  SMSClient* sms_client() {
209    return sms_client_.get();
210  }
211  UpdateEngineClient* update_engine_client() {
212    return update_engine_client_.get();
213  }
214
215 private:
216  scoped_ptr<BluetoothAdapterClient> bluetooth_adapter_client_;
217  scoped_ptr<BluetoothAgentManagerClient> bluetooth_agent_manager_client_;
218  scoped_ptr<BluetoothDeviceClient> bluetooth_device_client_;
219  scoped_ptr<BluetoothGattCharacteristicClient>
220      bluetooth_gatt_characteristic_client_;
221  scoped_ptr<BluetoothGattDescriptorClient> bluetooth_gatt_descriptor_client_;
222  scoped_ptr<BluetoothGattManagerClient> bluetooth_gatt_manager_client_;
223  scoped_ptr<BluetoothGattServiceClient> bluetooth_gatt_service_client_;
224  scoped_ptr<BluetoothInputClient> bluetooth_input_client_;
225  scoped_ptr<BluetoothProfileManagerClient> bluetooth_profile_manager_client_;
226  scoped_ptr<CrasAudioClient> cras_audio_client_;
227  scoped_ptr<CrosDisksClient> cros_disks_client_;
228  scoped_ptr<CryptohomeClient> cryptohome_client_;
229  scoped_ptr<DebugDaemonClient> debug_daemon_client_;
230  scoped_ptr<LorgnetteManagerClient> lorgnette_manager_client_;
231  scoped_ptr<ShillDeviceClient> shill_device_client_;
232  scoped_ptr<ShillIPConfigClient> shill_ipconfig_client_;
233  scoped_ptr<ShillManagerClient> shill_manager_client_;
234  scoped_ptr<ShillServiceClient> shill_service_client_;
235  scoped_ptr<ShillProfileClient> shill_profile_client_;
236  scoped_ptr<GsmSMSClient> gsm_sms_client_;
237  scoped_ptr<ImageBurnerClient> image_burner_client_;
238  scoped_ptr<IntrospectableClient> introspectable_client_;
239  scoped_ptr<ModemMessagingClient> modem_messaging_client_;
240  // The declaration order for NFC client objects is important. See
241  // DBusThreadManager::CreateDefaultClients for the dependencies.
242  scoped_ptr<NfcManagerClient> nfc_manager_client_;
243  scoped_ptr<NfcAdapterClient> nfc_adapter_client_;
244  scoped_ptr<NfcDeviceClient> nfc_device_client_;
245  scoped_ptr<NfcTagClient> nfc_tag_client_;
246  scoped_ptr<NfcRecordClient> nfc_record_client_;
247  scoped_ptr<PermissionBrokerClient> permission_broker_client_;
248  scoped_ptr<SystemClockClient> system_clock_client_;
249  scoped_ptr<PowerManagerClient> power_manager_client_;
250  scoped_ptr<SessionManagerClient> session_manager_client_;
251  scoped_ptr<SMSClient> sms_client_;
252  scoped_ptr<UpdateEngineClient> update_engine_client_;
253
254  DISALLOW_COPY_AND_ASSIGN(DBusClientBundle);
255};
256
257// The DBusThreadManager implementation used in production.
258class DBusThreadManagerImpl : public DBusThreadManager {
259 public:
260  explicit DBusThreadManagerImpl() {
261    // Create the D-Bus thread.
262    base::Thread::Options thread_options;
263    thread_options.message_loop_type = base::MessageLoop::TYPE_IO;
264    dbus_thread_.reset(new base::Thread("D-Bus thread"));
265    dbus_thread_->StartWithOptions(thread_options);
266
267    // Create the connection to the system bus.
268    dbus::Bus::Options system_bus_options;
269    system_bus_options.bus_type = dbus::Bus::SYSTEM;
270    system_bus_options.connection_type = dbus::Bus::PRIVATE;
271    system_bus_options.dbus_task_runner = dbus_thread_->message_loop_proxy();
272    system_bus_ = new dbus::Bus(system_bus_options);
273
274    CreateDefaultClients();
275  }
276
277  virtual ~DBusThreadManagerImpl() {
278    FOR_EACH_OBSERVER(DBusThreadManagerObserver, observers_,
279                      OnDBusThreadManagerDestroying(this));
280
281    // PowerPolicyController's destructor depends on PowerManagerClient.
282    power_policy_controller_.reset();
283
284    // Delete all D-Bus clients before shutting down the system bus.
285    client_bundle_.reset();
286
287    // Shut down the bus. During the browser shutdown, it's ok to shut down
288    // the bus synchronously.
289    system_bus_->ShutdownOnDBusThreadAndBlock();
290
291    // Stop the D-Bus thread.
292    dbus_thread_->Stop();
293  }
294
295  // DBusThreadManager overrides:
296  virtual void AddObserver(DBusThreadManagerObserver* observer) OVERRIDE {
297    DCHECK(observer);
298    observers_.AddObserver(observer);
299  }
300
301  virtual void RemoveObserver(DBusThreadManagerObserver* observer) OVERRIDE {
302    DCHECK(observer);
303    observers_.RemoveObserver(observer);
304  }
305
306  virtual dbus::Bus* GetSystemBus() OVERRIDE {
307    return system_bus_.get();
308  }
309
310  virtual BluetoothAdapterClient* GetBluetoothAdapterClient() OVERRIDE {
311    return client_bundle_->bluetooth_adapter_client();
312  }
313
314  virtual BluetoothAgentManagerClient* GetBluetoothAgentManagerClient()
315      OVERRIDE {
316    return client_bundle_->bluetooth_agent_manager_client();
317  }
318
319  virtual BluetoothDeviceClient* GetBluetoothDeviceClient() OVERRIDE {
320    return client_bundle_->bluetooth_device_client();
321  }
322
323  virtual BluetoothGattCharacteristicClient*
324      GetBluetoothGattCharacteristicClient() OVERRIDE {
325    return client_bundle_->bluetooth_gatt_characteristic_client();
326  }
327
328  virtual BluetoothGattDescriptorClient* GetBluetoothGattDescriptorClient()
329      OVERRIDE {
330    return client_bundle_->bluetooth_gatt_descriptor_client();
331  }
332
333  virtual BluetoothGattManagerClient* GetBluetoothGattManagerClient() OVERRIDE {
334    return client_bundle_->bluetooth_gatt_manager_client();
335  }
336
337  virtual BluetoothGattServiceClient* GetBluetoothGattServiceClient() OVERRIDE {
338    return client_bundle_->bluetooth_gatt_service_client();
339  }
340
341  virtual BluetoothInputClient* GetBluetoothInputClient() OVERRIDE {
342    return client_bundle_->bluetooth_input_client();
343  }
344
345  virtual BluetoothProfileManagerClient* GetBluetoothProfileManagerClient()
346      OVERRIDE {
347    return client_bundle_->bluetooth_profile_manager_client();
348  }
349
350  virtual CrasAudioClient* GetCrasAudioClient() OVERRIDE {
351    return client_bundle_->cras_audio_client();
352  }
353
354  virtual CrosDisksClient* GetCrosDisksClient() OVERRIDE {
355    return client_bundle_->cros_disks_client();
356  }
357
358  virtual CryptohomeClient* GetCryptohomeClient() OVERRIDE {
359    return client_bundle_->cryptohome_client();
360  }
361
362  virtual DebugDaemonClient* GetDebugDaemonClient() OVERRIDE {
363    return client_bundle_->debug_daemon_client();
364  }
365
366  virtual LorgnetteManagerClient* GetLorgnetteManagerClient() OVERRIDE {
367    return client_bundle_->lorgnette_manager_client();
368  }
369
370  virtual ShillDeviceClient* GetShillDeviceClient() OVERRIDE {
371    return client_bundle_->shill_device_client();
372  }
373
374  virtual ShillIPConfigClient* GetShillIPConfigClient() OVERRIDE {
375    return client_bundle_->shill_ipconfig_client();
376  }
377
378  virtual ShillManagerClient* GetShillManagerClient() OVERRIDE {
379    return client_bundle_->shill_manager_client();
380  }
381
382  virtual ShillServiceClient* GetShillServiceClient() OVERRIDE {
383    return client_bundle_->shill_service_client();
384  }
385
386  virtual ShillProfileClient* GetShillProfileClient() OVERRIDE {
387    return client_bundle_->shill_profile_client();
388  }
389
390  virtual GsmSMSClient* GetGsmSMSClient() OVERRIDE {
391    return client_bundle_->gsm_sms_client();
392  }
393
394  virtual ImageBurnerClient* GetImageBurnerClient() OVERRIDE {
395    return client_bundle_->image_burner_client();
396  }
397
398  virtual IntrospectableClient* GetIntrospectableClient() OVERRIDE {
399    return client_bundle_->introspectable_client();
400  }
401
402  virtual ModemMessagingClient* GetModemMessagingClient() OVERRIDE {
403    return client_bundle_->modem_messaging_client();
404  }
405
406  virtual NfcAdapterClient* GetNfcAdapterClient() OVERRIDE {
407    return client_bundle_->nfc_adapter_client();
408  }
409
410  virtual NfcDeviceClient* GetNfcDeviceClient() OVERRIDE {
411    return client_bundle_->nfc_device_client();
412  }
413
414  virtual NfcManagerClient* GetNfcManagerClient() OVERRIDE {
415    return client_bundle_->nfc_manager_client();
416  }
417
418  virtual NfcRecordClient* GetNfcRecordClient() OVERRIDE {
419    return client_bundle_->nfc_record_client();
420  }
421
422  virtual NfcTagClient* GetNfcTagClient() OVERRIDE {
423    return client_bundle_->nfc_tag_client();
424  }
425
426  virtual PermissionBrokerClient* GetPermissionBrokerClient() OVERRIDE {
427    return client_bundle_->permission_broker_client();
428  }
429
430  virtual PowerManagerClient* GetPowerManagerClient() OVERRIDE {
431    return client_bundle_->power_manager_client();
432  }
433
434  virtual SessionManagerClient* GetSessionManagerClient() OVERRIDE {
435    return client_bundle_->session_manager_client();
436  }
437
438  virtual SMSClient* GetSMSClient() OVERRIDE {
439    return client_bundle_->sms_client();
440  }
441
442  virtual SystemClockClient* GetSystemClockClient() OVERRIDE {
443    return client_bundle_->system_clock_client();
444  }
445
446  virtual UpdateEngineClient* GetUpdateEngineClient() OVERRIDE {
447    return client_bundle_->update_engine_client();
448  }
449
450  virtual PowerPolicyController* GetPowerPolicyController() OVERRIDE {
451    return power_policy_controller_.get();
452  }
453
454 private:
455  // Constructs all clients and stores them in the respective *_client_ member
456  // variable.
457  void CreateDefaultClients() {
458    client_bundle_.reset(new DBusClientBundle);
459    power_policy_controller_.reset(new PowerPolicyController);
460  }
461
462  // Note: Keep this before other members so they can call AddObserver() in
463  // their c'tors.
464  ObserverList<DBusThreadManagerObserver> observers_;
465
466  scoped_ptr<base::Thread> dbus_thread_;
467  scoped_refptr<dbus::Bus> system_bus_;
468  scoped_ptr<DBusClientBundle> client_bundle_;
469  scoped_ptr<PowerPolicyController> power_policy_controller_;
470};
471
472// static
473void DBusThreadManager::Initialize() {
474  // If we initialize DBusThreadManager twice we may also be shutting it down
475  // early; do not allow that.
476  CHECK(g_dbus_thread_manager == NULL);
477
478  if (g_dbus_thread_manager_for_testing) {
479    g_dbus_thread_manager = g_dbus_thread_manager_for_testing;
480    InitializeClients();
481    VLOG(1) << "DBusThreadManager initialized with test implementation";
482    return;
483  }
484
485  // Determine whether we use stub or real client implementations.
486  if (!base::SysInfo::IsRunningOnChromeOS() ||
487      CommandLine::ForCurrentProcess()->HasSwitch(
488          chromeos::switches::kDbusStub)) {
489    InitializeWithStub();
490  } else {
491    g_dbus_thread_manager = new DBusThreadManagerImpl;
492    InitializeClients();
493    VLOG(1) << "DBusThreadManager initialized for Chrome OS";
494  }
495}
496
497// static
498void DBusThreadManager::SetInstanceForTesting(
499    DBusThreadManager* dbus_thread_manager) {
500  CHECK(!g_dbus_thread_manager);
501  CHECK(!g_dbus_thread_manager_for_testing);
502  g_dbus_thread_manager_for_testing = dbus_thread_manager;
503}
504
505// static
506void DBusThreadManager::InitializeForTesting(
507    DBusThreadManager* dbus_thread_manager) {
508  SetInstanceForTesting(dbus_thread_manager);
509  Initialize();
510}
511
512// static
513void DBusThreadManager::InitializeWithStub() {
514  // If we initialize DBusThreadManager twice we may also be shutting it down
515  // early; do not allow that.
516  CHECK(g_dbus_thread_manager == NULL);
517  FakeDBusThreadManager* fake_dbus_thread_manager = new FakeDBusThreadManager;
518  fake_dbus_thread_manager->SetFakeClients();
519  g_dbus_thread_manager = fake_dbus_thread_manager;
520  InitializeClients();
521  fake_dbus_thread_manager->SetupDefaultEnvironment();
522  VLOG(1) << "DBusThreadManager initialized with stub implementation";
523}
524
525// static
526bool DBusThreadManager::IsInitialized() {
527  return g_dbus_thread_manager != NULL;
528}
529
530// static
531void DBusThreadManager::Shutdown() {
532  // If we called InitializeForTesting, this may get called more than once.
533  // Ensure that we only shutdown DBusThreadManager once.
534  CHECK(g_dbus_thread_manager || g_dbus_thread_manager_for_testing);
535  DBusThreadManager* dbus_thread_manager = g_dbus_thread_manager;
536  g_dbus_thread_manager = NULL;
537  g_dbus_thread_manager_for_testing = NULL;
538  delete dbus_thread_manager;
539  VLOG(1) << "DBusThreadManager Shutdown completed";
540}
541
542DBusThreadManager::DBusThreadManager() {
543  dbus::statistics::Initialize();
544}
545
546DBusThreadManager::~DBusThreadManager() {
547  dbus::statistics::Shutdown();
548  if (g_dbus_thread_manager == NULL)
549    return;  // Called form Shutdown() or local test instance.
550  // There should never be both a global instance and a local instance.
551  CHECK(this == g_dbus_thread_manager);
552  if (g_dbus_thread_manager_for_testing) {
553    g_dbus_thread_manager = NULL;
554    g_dbus_thread_manager_for_testing = NULL;
555    VLOG(1) << "DBusThreadManager destroyed";
556  } else {
557    LOG(FATAL) << "~DBusThreadManager() called outside of Shutdown()";
558  }
559}
560
561// static
562DBusThreadManager* DBusThreadManager::Get() {
563  CHECK(g_dbus_thread_manager)
564      << "DBusThreadManager::Get() called before Initialize()";
565  return g_dbus_thread_manager;
566}
567
568// static
569void DBusThreadManager::InitializeClients() {
570  InitClient(g_dbus_thread_manager->GetBluetoothAdapterClient());
571  InitClient(g_dbus_thread_manager->GetBluetoothAgentManagerClient());
572  InitClient(g_dbus_thread_manager->GetBluetoothDeviceClient());
573  InitClient(g_dbus_thread_manager->GetBluetoothGattCharacteristicClient());
574  InitClient(g_dbus_thread_manager->GetBluetoothGattDescriptorClient());
575  InitClient(g_dbus_thread_manager->GetBluetoothGattManagerClient());
576  InitClient(g_dbus_thread_manager->GetBluetoothGattServiceClient());
577  InitClient(g_dbus_thread_manager->GetBluetoothInputClient());
578  InitClient(g_dbus_thread_manager->GetBluetoothProfileManagerClient());
579  InitClient(g_dbus_thread_manager->GetCrasAudioClient());
580  InitClient(g_dbus_thread_manager->GetCrosDisksClient());
581  InitClient(g_dbus_thread_manager->GetCryptohomeClient());
582  InitClient(g_dbus_thread_manager->GetDebugDaemonClient());
583  InitClient(g_dbus_thread_manager->GetGsmSMSClient());
584  InitClient(g_dbus_thread_manager->GetImageBurnerClient());
585  InitClient(g_dbus_thread_manager->GetIntrospectableClient());
586  InitClient(g_dbus_thread_manager->GetLorgnetteManagerClient());
587  InitClient(g_dbus_thread_manager->GetModemMessagingClient());
588  InitClient(g_dbus_thread_manager->GetPermissionBrokerClient());
589  InitClient(g_dbus_thread_manager->GetPowerManagerClient());
590  InitClient(g_dbus_thread_manager->GetSessionManagerClient());
591  InitClient(g_dbus_thread_manager->GetShillDeviceClient());
592  InitClient(g_dbus_thread_manager->GetShillIPConfigClient());
593  InitClient(g_dbus_thread_manager->GetShillManagerClient());
594  InitClient(g_dbus_thread_manager->GetShillServiceClient());
595  InitClient(g_dbus_thread_manager->GetShillProfileClient());
596  InitClient(g_dbus_thread_manager->GetSMSClient());
597  InitClient(g_dbus_thread_manager->GetSystemClockClient());
598  InitClient(g_dbus_thread_manager->GetUpdateEngineClient());
599
600  // Initialize the NFC clients in the correct order. The order of
601  // initialization matters due to dependencies that exist between the
602  // client objects.
603  InitClient(g_dbus_thread_manager->GetNfcManagerClient());
604  InitClient(g_dbus_thread_manager->GetNfcAdapterClient());
605  InitClient(g_dbus_thread_manager->GetNfcDeviceClient());
606  InitClient(g_dbus_thread_manager->GetNfcTagClient());
607  InitClient(g_dbus_thread_manager->GetNfcRecordClient());
608
609  // PowerPolicyController is dependent on PowerManagerClient, so
610  // initialize it after the main list of clients.
611  if (g_dbus_thread_manager->GetPowerPolicyController()) {
612    g_dbus_thread_manager->GetPowerPolicyController()->Init(
613        g_dbus_thread_manager);
614  }
615
616  // This must be called after the list of clients so they've each had a
617  // chance to register with their object g_dbus_thread_managers.
618  if (g_dbus_thread_manager->GetSystemBus())
619    g_dbus_thread_manager->GetSystemBus()->GetManagedObjects();
620}
621
622// static
623void DBusThreadManager::InitClient(DBusClient* client) {
624  if (client)
625    client->Init(g_dbus_thread_manager->GetSystemBus());
626}
627
628}  // namespace chromeos
629