Pass signin_scoped_device_id to DeviceInfoSpecifics.

chrome/browser/sync/glue/synced_device_tracker.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 "chrome/browser/sync/glue/synced_device_tracker.h"
 
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/sync/glue/device_info.h"
 #include "sync/internal_api/public/base/model_type.h"
@@ skipping 49 matching lines @@
 
 scoped_ptr<DeviceInfo> SyncedDeviceTracker::ReadLocalDeviceInfo(
     const syncer::BaseTransaction& trans) const {
   syncer::ReadNode node(&trans);
   if (node.InitByClientTagLookup(syncer::DEVICE_INFO, local_device_info_tag_) !=
       syncer::BaseNode::INIT_OK) {
     return scoped_ptr<DeviceInfo>();
   }
 
   const sync_pb::DeviceInfoSpecifics& specifics = node.GetDeviceInfoSpecifics();
-  return scoped_ptr<DeviceInfo> (
+  return scoped_ptr<DeviceInfo>(
       new DeviceInfo(specifics.cache_guid(),
                      specifics.client_name(),
                      specifics.chrome_version(),
                      specifics.sync_user_agent(),
-                     specifics.device_type()));
+                     specifics.device_type(),
+                     specifics.signin_scoped_device_id()));
 }
 
 scoped_ptr<DeviceInfo> SyncedDeviceTracker::ReadDeviceInfo(
     const std::string& client_id) const {
   syncer::ReadTransaction trans(FROM_HERE, user_share_);
   syncer::ReadNode node(&trans);
   std::string lookup_string = DeviceInfoLookupString(client_id);
   if (node.InitByClientTagLookup(syncer::DEVICE_INFO, lookup_string) !=
       syncer::BaseNode::INIT_OK) {
     return scoped_ptr<DeviceInfo>();
   }
 
   const sync_pb::DeviceInfoSpecifics& specifics = node.GetDeviceInfoSpecifics();
-  return scoped_ptr<DeviceInfo> (
+  return scoped_ptr<DeviceInfo>(
       new DeviceInfo(specifics.cache_guid(),
                      specifics.client_name(),
                      specifics.chrome_version(),
                      specifics.sync_user_agent(),
-                     specifics.device_type()));
+                     specifics.device_type(),
+                     specifics.signin_scoped_device_id()));
 }
 
 void SyncedDeviceTracker::GetAllSyncedDeviceInfo(
     ScopedVector<DeviceInfo>* device_info) const {
   if (device_info == NULL)
     return;
 
   device_info->clear();
 
   syncer::ReadTransaction trans(FROM_HERE, user_share_);
@@ skipping 10 matching lines @@
   root_node.GetChildIds(&children);
 
   for (std::vector<int64>::const_iterator it = children.begin();
        it != children.end(); ++it) {
     syncer::ReadNode node(&trans);
     if (node.InitByIdLookup(*it) != syncer::BaseNode::INIT_OK)
       return;
 
     const sync_pb::DeviceInfoSpecifics& specifics =
         node.GetDeviceInfoSpecifics();
-    device_info->push_back(
-        new DeviceInfo(specifics.cache_guid(),
-                       specifics.client_name(),
-                       specifics.chrome_version(),
-                       specifics.sync_user_agent(),
-                       specifics.device_type()));
+    device_info->push_back(new DeviceInfo(specifics.cache_guid(),
+                                          specifics.client_name(),
+                                          specifics.chrome_version(),
+                                          specifics.sync_user_agent(),
+                                          specifics.device_type(),
+                                          specifics.signin_scoped_device_id()));
   }
 }
 
 std::string SyncedDeviceTracker::cache_guid() const {
   return cache_guid_;
 }
 
 void SyncedDeviceTracker::AddObserver(Observer* observer) {
   observers_->AddObserver(observer);
 }
 
 void SyncedDeviceTracker::RemoveObserver(Observer* observer) {
   observers_->RemoveObserver(observer);
 }
 
-void SyncedDeviceTracker::InitLocalDeviceInfo(const base::Closure& callback) {
+void SyncedDeviceTracker::InitLocalDeviceInfo(
+    const std::string& signin_scoped_device_id,
+    const base::Closure& callback) {
   DeviceInfo::CreateLocalDeviceInfo(
       cache_guid_,
+      signin_scoped_device_id,
       base::Bind(&SyncedDeviceTracker::InitLocalDeviceInfoContinuation,
-                 weak_factory_.GetWeakPtr(), callback));
+                 weak_factory_.GetWeakPtr(),
+                 callback));
 }
 
 void SyncedDeviceTracker::InitLocalDeviceInfoContinuation(
     const base::Closure& callback, const DeviceInfo& local_info) {
   WriteLocalDeviceInfo(local_info);
   callback.Run();
 }
 
 void SyncedDeviceTracker::WriteLocalDeviceInfo(const DeviceInfo& info) {
   sync_pb::DeviceInfoSpecifics specifics;
   DCHECK_EQ(cache_guid_, info.guid());
   specifics.set_cache_guid(cache_guid_);
   specifics.set_client_name(info.client_name());
   specifics.set_chrome_version(info.chrome_version());
   specifics.set_sync_user_agent(info.sync_user_agent());
   specifics.set_device_type(info.device_type());
+  specifics.set_signin_scoped_device_id(info.signin_scoped_device_id());
 
   WriteDeviceInfo(specifics, local_device_info_tag_);
 }
 
 void SyncedDeviceTracker::WriteDeviceInfo(
     const sync_pb::DeviceInfoSpecifics& specifics,
     const std::string& tag) {
   syncer::WriteTransaction trans(FROM_HERE, user_share_);
   syncer::WriteNode node(&trans);
 
@@ skipping 12 matching lines @@
         new_node.InitUniqueByCreation(syncer::DEVICE_INFO,
                                       type_root,
                                       tag);
     DCHECK_EQ(syncer::WriteNode::INIT_SUCCESS, create_result);
     new_node.SetDeviceInfoSpecifics(specifics);
     new_node.SetTitle(specifics.client_name());
   }
 }
 
 }  // namespace browser_sync