Refactor syncable DEVICE_INFO type from ChangeProcessor to SyncableService - part 3.

chrome/browser/extensions/api/signed_in_devices/signed_in_devices_api.cc

 // Copyright (c) 2013 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/browser/extensions/api/signed_in_devices/signed_in_devices_api.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/signed_in_devices/id_mapping_helper.h"
 #include "chrome/browser/profiles/profile.h"
-#include "chrome/browser/sync/glue/device_info.h"
+#include "chrome/browser/sync/glue/device_info_tracker.h"
 #include "chrome/browser/sync/glue/local_device_info_provider.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/common/extensions/api/signed_in_devices.h"
 #include "extensions/browser/extension_prefs.h"
 
 using base::DictionaryValue;
 using browser_sync::DeviceInfo;
+using browser_sync::DeviceInfoTracker;
 using browser_sync::LocalDeviceInfoProvider;
 
 namespace extensions {
 
 static const char kPrefStringForIdMapping[] = "id_mapping_dictioanry";
 
 // Gets the dictionary that stores the id mapping. The dictionary is stored
 // in the |ExtensionPrefs|.
 const base::DictionaryValue* GetIdMappingDictionary(
     ExtensionPrefs* extension_prefs,
@@ skipping 10 matching lines @@
     extension_prefs->UpdateExtensionPref(
         extension_id,
         kPrefStringForIdMapping,
         dictionary.release());
   }
 
   return out_value;
 }
 
 // Helper routine to get all signed in devices. The helper takes in
-// the pointers for |ProfileSyncService| and |Extensionprefs|. This
+// the pointers for |DeviceInfoTracker| and |Extensionprefs|. This
 // makes it easier to test by passing mock values for these pointers.
 ScopedVector<DeviceInfo> GetAllSignedInDevices(
     const std::string& extension_id,
-    ProfileSyncService* pss,
+    DeviceInfoTracker* device_tracker,
     ExtensionPrefs* extension_prefs) {
-  ScopedVector<DeviceInfo> devices = pss->GetAllSignedInDevices();
+  ScopedVector<DeviceInfo> devices = device_tracker->GetAllDeviceInfo();
   const base::DictionaryValue* mapping_dictionary = GetIdMappingDictionary(
       extension_prefs,
       extension_id);
 
   CHECK(mapping_dictionary);
 
   // |mapping_dictionary| is const. So make an editable copy.
   scoped_ptr<base::DictionaryValue> editable_mapping_dictionary(
       mapping_dictionary->DeepCopy());
 
   CreateMappingForUnmappedDevices(&(devices.get()),
                                   editable_mapping_dictionary.get());
 
   // Write into |ExtensionPrefs| which will get persisted in disk.
   extension_prefs->UpdateExtensionPref(extension_id,
                                        kPrefStringForIdMapping,
                                        editable_mapping_dictionary.release());
   return devices.Pass();
 }
 
 ScopedVector<DeviceInfo> GetAllSignedInDevices(
     const std::string& extension_id,
     Profile* profile) {
-  // Get the profile sync service and extension prefs pointers
+  // Get the device tracker and extension prefs pointers
   // and call the helper.
-  ProfileSyncService* pss = ProfileSyncServiceFactory::GetForProfile(profile);
+  DeviceInfoTracker* device_tracker =
+      ProfileSyncServiceFactory::GetForProfile(profile)->GetDeviceInfoTracker();

[pavely, 2014/09/17 23:04:38]

What is the condition when GetDeviceInfoTracker() may return NULL?
Will it be a problem in GetAllSignedInDevices?

[stanisc, 2014/09/18 22:46:53]

Good catch! It could only be null if either Sync backend or local device info
haven't initialized.
The old code handled this condition. I added a check to return an empty
ScopedVector<DeviceInfo> in that case. Also I've added a unit test to verify
this code handles NULL DeviceInfoTracker as expected.

   ExtensionPrefs* extension_prefs = ExtensionPrefs::Get(profile);
 
-  return GetAllSignedInDevices(extension_id,
-                               pss,
-                               extension_prefs);
+  return GetAllSignedInDevices(extension_id, device_tracker, extension_prefs);
 }
 
 scoped_ptr<DeviceInfo> GetLocalDeviceInfo(const std::string& extension_id,
                                           Profile* profile) {
   ProfileSyncService* pss = ProfileSyncServiceFactory::GetForProfile(profile);
   if (!pss) {
     return scoped_ptr<DeviceInfo>();
   }
 
   LocalDeviceInfoProvider* local_device = pss->GetLocalDeviceInfoProvider();
@@ skipping 33 matching lines @@
        ++it) {
     result->Append((*it)->ToValue());
   }
 
   SetResult(result.release());
   return true;
 }
 
 }  // namespace extensions