Pass signin_scoped_device_id to DeviceInfoSpecifics.

chrome/browser/sync/glue/device_info.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/device_info.h"
 
 #include "base/command_line.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/values.h"
 #include "chrome/common/chrome_version_info.h"
@@ skipping 21 matching lines @@
       return "canary";
     case chrome::VersionInfo::CHANNEL_DEV:
       return "dev";
     case chrome::VersionInfo::CHANNEL_BETA:
       return "beta";
     case chrome::VersionInfo::CHANNEL_STABLE:
       return "stable";
     default:
       NOTREACHED();
       return "unknown";
-  };
+  }
 }
 
 }  // namespace
 
 DeviceInfo::DeviceInfo(const std::string& guid,
                        const std::string& client_name,
                        const std::string& chrome_version,
                        const std::string& sync_user_agent,
-                       const sync_pb::SyncEnums::DeviceType device_type)
+                       const sync_pb::SyncEnums::DeviceType device_type,
+                       const std::string& signin_scoped_device_id)
     : guid_(guid),
       client_name_(client_name),
       chrome_version_(chrome_version),
       sync_user_agent_(sync_user_agent),
-      device_type_(device_type) {
+      device_type_(device_type),
+      signin_scoped_device_id_(signin_scoped_device_id) {
 }
 
 DeviceInfo::~DeviceInfo() { }
 
 const std::string& DeviceInfo::guid() const {
   return guid_;
 }
 
 const std::string& DeviceInfo::client_name() const {
   return client_name_;
 }
 
 const std::string& DeviceInfo::chrome_version() const {
   return chrome_version_;
 }
 
 const std::string& DeviceInfo::sync_user_agent() const {
   return sync_user_agent_;
 }
 
 const std::string& DeviceInfo::public_id() const {
   return public_id_;
 }
 
 sync_pb::SyncEnums::DeviceType DeviceInfo::device_type() const {
   return device_type_;
 }
 
+const std::string& DeviceInfo::signin_scoped_device_id() const {
+  return signin_scoped_device_id_;
+}
+
 std::string DeviceInfo::GetOSString() const {
   switch (device_type_) {
     case sync_pb::SyncEnums_DeviceType_TYPE_WIN:
       return "win";
     case sync_pb::SyncEnums_DeviceType_TYPE_MAC:
       return "mac";
     case sync_pb::SyncEnums_DeviceType_TYPE_LINUX:
       return "linux";
     case sync_pb::SyncEnums_DeviceType_TYPE_CROS:
       return "chrome_os";
@@ skipping 17 matching lines @@
     case sync_pb::SyncEnums_DeviceType_TYPE_PHONE:
       return "phone";
     case sync_pb::SyncEnums_DeviceType_TYPE_TABLET:
       return "tablet";
     default:
       return "unknown";
   }
 }
 
 bool DeviceInfo::Equals(const DeviceInfo& other) const {
-  return this->guid() == other.guid()
-      && this->client_name() == other.client_name()
-      && this->chrome_version() == other.chrome_version()
-      && this->sync_user_agent() == other.sync_user_agent()
-      && this->device_type() == other.device_type();
+  return this->guid() == other.guid() &&
+         this->client_name() == other.client_name() &&
+         this->chrome_version() == other.chrome_version() &&
+         this->sync_user_agent() == other.sync_user_agent() &&
+         this->device_type() == other.device_type() &&
+         this->signin_scoped_device_id() == other.signin_scoped_device_id();
 }
 
 // static.
 sync_pb::SyncEnums::DeviceType DeviceInfo::GetLocalDeviceType() {
 #if defined(OS_CHROMEOS)
   return sync_pb::SyncEnums_DeviceType_TYPE_CROS;
 #elif defined(OS_LINUX)
   return sync_pb::SyncEnums_DeviceType_TYPE_LINUX;
 #elif defined(OS_MACOSX)
   return sync_pb::SyncEnums_DeviceType_TYPE_MAC;
@@ skipping 58 matching lines @@
   return value;
 }
 
 void DeviceInfo::set_public_id(std::string id) {
   public_id_ = id;
 }
 
 // static.
 void DeviceInfo::CreateLocalDeviceInfo(
     const std::string& guid,
+    const std::string& signin_scoped_device_id,
     base::Callback<void(const DeviceInfo& local_info)> callback) {
-  GetClientName(
-      base::Bind(&DeviceInfo::CreateLocalDeviceInfoContinuation,
-                 guid,
-                 callback));
+  GetClientName(base::Bind(&DeviceInfo::CreateLocalDeviceInfoContinuation,
+                           guid,
+                           signin_scoped_device_id,
+                           callback));
 }
 
 // static.
 void DeviceInfo::GetClientName(
     base::Callback<void(const std::string& client_name)> callback) {
   syncer::GetSessionName(
       content::BrowserThread::GetBlockingPool(),
       base::Bind(&DeviceInfo::GetClientNameContinuation,
                  callback));
 }
 
 void DeviceInfo::GetClientNameContinuation(
     base::Callback<void(const std::string& local_info)> callback,
     const std::string& session_name) {
   callback.Run(session_name);
 }
 
 // static.
 void DeviceInfo::CreateLocalDeviceInfoContinuation(
     const std::string& guid,
+    const std::string& signin_scoped_device_id,
     base::Callback<void(const DeviceInfo& local_info)> callback,
     const std::string& session_name) {
   chrome::VersionInfo version_info;
 
-  DeviceInfo local_info(
-      guid,
-      session_name,
-      version_info.CreateVersionString(),
-      MakeUserAgentForSyncApi(version_info),
-      GetLocalDeviceType());
+  DeviceInfo local_info(guid,
+                        session_name,
+                        version_info.CreateVersionString(),
+                        MakeUserAgentForSyncApi(version_info),
+                        GetLocalDeviceType(),
+                        signin_scoped_device_id);
 
   callback.Run(local_info);
 }
 
 }  // namespace browser_sync