1 // Copyright (c) 2013 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 "chrome/browser/extensions/api/signed_in_devices/signed_in_devices_api.h"
6
7 #include "base/memory/scoped_ptr.h"
8 #include "base/memory/scoped_vector.h"
9 #include "base/values.h"
10 #include "chrome/browser/extensions/api/signed_in_devices/id_mapping_helper.h"
11 #include "chrome/browser/profiles/profile.h"
12 #include "chrome/browser/sync/profile_sync_service.h"
13 #include "chrome/browser/sync/profile_sync_service_factory.h"
14 #include "chrome/common/extensions/api/signed_in_devices.h"
15 #include "components/sync_driver/device_info_tracker.h"
16 #include "components/sync_driver/local_device_info_provider.h"
17 #include "extensions/browser/extension_prefs.h"
18
19 using base::DictionaryValue;
20 using sync_driver::DeviceInfo;
21 using sync_driver::DeviceInfoTracker;
22 using sync_driver::LocalDeviceInfoProvider;
23
24 namespace extensions {
25
26 static const char kPrefStringForIdMapping[] = "id_mapping_dictioanry";
27
28 // Gets the dictionary that stores the id mapping. The dictionary is stored
29 // in the |ExtensionPrefs|.
GetIdMappingDictionary(ExtensionPrefs * extension_prefs,const std::string & extension_id)30 const base::DictionaryValue* GetIdMappingDictionary(
31 ExtensionPrefs* extension_prefs,
32 const std::string& extension_id) {
33 const base::DictionaryValue* out_value = NULL;
34 if (!extension_prefs->ReadPrefAsDictionary(
35 extension_id,
36 kPrefStringForIdMapping,
37 &out_value) || out_value == NULL) {
38 // Looks like this is the first call to get the dictionary. Let us create
39 // a dictionary and set it in to |extension_prefs|.
40 scoped_ptr<base::DictionaryValue> dictionary(new base::DictionaryValue());
41 out_value = dictionary.get();
42 extension_prefs->UpdateExtensionPref(
43 extension_id,
44 kPrefStringForIdMapping,
45 dictionary.release());
46 }
47
48 return out_value;
49 }
50
51 // Helper routine to get all signed in devices. The helper takes in
52 // the pointers for |DeviceInfoTracker| and |Extensionprefs|. This
53 // makes it easier to test by passing mock values for these pointers.
GetAllSignedInDevices(const std::string & extension_id,DeviceInfoTracker * device_tracker,ExtensionPrefs * extension_prefs)54 ScopedVector<DeviceInfo> GetAllSignedInDevices(
55 const std::string& extension_id,
56 DeviceInfoTracker* device_tracker,
57 ExtensionPrefs* extension_prefs) {
58 DCHECK(device_tracker);
59 ScopedVector<DeviceInfo> devices = device_tracker->GetAllDeviceInfo();
60 const base::DictionaryValue* mapping_dictionary = GetIdMappingDictionary(
61 extension_prefs,
62 extension_id);
63
64 CHECK(mapping_dictionary);
65
66 // |mapping_dictionary| is const. So make an editable copy.
67 scoped_ptr<base::DictionaryValue> editable_mapping_dictionary(
68 mapping_dictionary->DeepCopy());
69
70 CreateMappingForUnmappedDevices(&(devices.get()),
71 editable_mapping_dictionary.get());
72
73 // Write into |ExtensionPrefs| which will get persisted in disk.
74 extension_prefs->UpdateExtensionPref(extension_id,
75 kPrefStringForIdMapping,
76 editable_mapping_dictionary.release());
77 return devices.Pass();
78 }
79
GetAllSignedInDevices(const std::string & extension_id,Profile * profile)80 ScopedVector<DeviceInfo> GetAllSignedInDevices(
81 const std::string& extension_id,
82 Profile* profile) {
83 // Get the device tracker and extension prefs pointers
84 // and call the helper.
85 DeviceInfoTracker* device_tracker =
86 ProfileSyncServiceFactory::GetForProfile(profile)->GetDeviceInfoTracker();
87 if (device_tracker == NULL) {
88 // Devices are not sync'ing.
89 return ScopedVector<DeviceInfo>().Pass();
90 }
91
92 ExtensionPrefs* extension_prefs = ExtensionPrefs::Get(profile);
93
94 return GetAllSignedInDevices(extension_id, device_tracker, extension_prefs);
95 }
96
GetLocalDeviceInfo(const std::string & extension_id,Profile * profile)97 scoped_ptr<DeviceInfo> GetLocalDeviceInfo(const std::string& extension_id,
98 Profile* profile) {
99 ProfileSyncService* pss = ProfileSyncServiceFactory::GetForProfile(profile);
100 if (!pss) {
101 return scoped_ptr<DeviceInfo>();
102 }
103
104 LocalDeviceInfoProvider* local_device = pss->GetLocalDeviceInfoProvider();
105 DCHECK(local_device);
106 std::string guid = local_device->GetLocalSyncCacheGUID();
107 scoped_ptr<DeviceInfo> device = GetDeviceInfoForClientId(guid,
108 extension_id,
109 profile);
110 return device.Pass();
111 }
112
RunSync()113 bool SignedInDevicesGetFunction::RunSync() {
114 scoped_ptr<api::signed_in_devices::Get::Params> params(
115 api::signed_in_devices::Get::Params::Create(*args_));
116 EXTENSION_FUNCTION_VALIDATE(params.get());
117
118 bool is_local = params->is_local.get() ? *params->is_local : false;
119
120 if (is_local) {
121 scoped_ptr<DeviceInfo> device =
122 GetLocalDeviceInfo(extension_id(), GetProfile());
123 base::ListValue* result = new base::ListValue();
124 if (device.get()) {
125 result->Append(device->ToValue());
126 }
127 SetResult(result);
128 return true;
129 }
130
131 ScopedVector<DeviceInfo> devices =
132 GetAllSignedInDevices(extension_id(), GetProfile());
133
134 scoped_ptr<base::ListValue> result(new base::ListValue());
135
136 for (ScopedVector<DeviceInfo>::const_iterator it = devices.begin();
137 it != devices.end();
138 ++it) {
139 result->Append((*it)->ToValue());
140 }
141
142 SetResult(result.release());
143 return true;
144 }
145
146 } // namespace extensions
147
148