sync: Add DeviceInfo protobuf and supporting code

chrome/browser/sync/glue/session_model_associator.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/session_model_associator.h"
 
 #include <algorithm>
 #include <set>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "chrome/browser/favicon/favicon_service_factory.h"
 #include "chrome/browser/history/history.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/session_id.h"
+#include "chrome/browser/sync/glue/device_info.h"
 #include "chrome/browser/sync/glue/synced_session.h"
 #include "chrome/browser/sync/glue/synced_tab_delegate.h"
 #include "chrome/browser/sync/glue/synced_window_delegate.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_details.h"
@@ skipping 38 matching lines @@
 // Default number of days without activity after which a session is considered
 // stale and becomes a candidate for garbage collection.
 static const size_t kDefaultStaleSessionThresholdDays = 14;  // 2 weeks.
 
 #if defined(OS_ANDROID)
 bool IsTabletUI() {
   return CommandLine::ForCurrentProcess()->HasSwitch(switches::kTabletUI);
 }
 #endif
 
-sync_pb::SessionHeader::DeviceType GetLocalDeviceType() {
-  // TODO(yfriedman): Refactor/combine with "DeviceInformation" code in
-  // sync_manager.cc[1060]
-#if defined(OS_CHROMEOS)
-  return sync_pb::SessionHeader_DeviceType_TYPE_CROS;
-#elif defined(OS_LINUX)
-  return sync_pb::SessionHeader_DeviceType_TYPE_LINUX;
-#elif defined(OS_MACOSX)
-  return sync_pb::SessionHeader_DeviceType_TYPE_MAC;
-#elif defined(OS_WIN)
-  return sync_pb::SessionHeader_DeviceType_TYPE_WIN;
-#elif defined(OS_ANDROID)
-  return IsTabletUI() ?
-      sync_pb::SessionHeader_DeviceType_TYPE_TABLET :
-      sync_pb::SessionHeader_DeviceType_TYPE_PHONE;
-#else
-  return sync_pb::SessionHeader_DeviceType_TYPE_OTHER;
-#endif
-}
-
 }  // namespace
 
 SessionModelAssociator::SessionModelAssociator(ProfileSyncService* sync_service,
     DataTypeErrorHandler* error_handler)
     : tab_pool_(sync_service),
       local_session_syncid_(syncer::kInvalidId),
       sync_service_(sync_service),
       stale_session_threshold_days_(kDefaultStaleSessionThresholdDays),
       setup_for_test_(false),
       waiting_for_change_(false),
@@ skipping 87 matching lines @@
                                               syncer::SyncError* error) {
   DCHECK(CalledOnValidThread());
   std::string local_tag = GetCurrentMachineTag();
   sync_pb::SessionSpecifics specifics;
   specifics.set_session_tag(local_tag);
   sync_pb::SessionHeader* header_s = specifics.mutable_header();
   SyncedSession* current_session =
       synced_session_tracker_.GetSession(local_tag);
   current_session->modified_time = base::Time::Now();
   header_s->set_client_name(current_session_name_);
-  header_s->set_device_type(GetLocalDeviceType());
+  header_s->set_device_type(DeviceInfo::GetLocalDeviceType());
 
   synced_session_tracker_.ResetSessionTracking(local_tag);
   std::set<SyncedWindowDelegate*> windows =
       SyncedWindowDelegate::GetSyncedWindowDelegates();
   for (std::set<SyncedWindowDelegate*>::const_iterator i =
            windows.begin(); i != windows.end(); ++i) {
     // Make sure the window has tabs and a viewable window. The viewable window
     // check is necessary because, for example, when a browser is closed the
     // destructor is not necessarily run immediately. This means its possible
     // for us to get a handle to a browser that is about to be removed. If
@@ skipping 437 matching lines @@
             model_type());
       }
 
       // Write the initial values to the specifics so that in case of a crash or
       // error we don't persist a half-written node.
       write_node.SetTitle(UTF8ToWide(current_machine_tag_));
       sync_pb::SessionSpecifics base_specifics;
       base_specifics.set_session_tag(current_machine_tag_);
       sync_pb::SessionHeader* header_s = base_specifics.mutable_header();
       header_s->set_client_name(current_session_name_);
-      header_s->set_device_type(GetLocalDeviceType());
+      header_s->set_device_type(DeviceInfo::GetLocalDeviceType());
       write_node.SetSessionSpecifics(base_specifics);
 
       local_session_syncid_ = write_node.GetId();
     }
   }
 
   // Check if anything has changed on the client side.
   if (!UpdateSyncModelDataFromClient(&error)) {
     DCHECK(error.IsSet());
     return error;
@@ skipping 305 matching lines @@
 // Static
 void SessionModelAssociator::PopulateSessionHeaderFromSpecifics(
     const sync_pb::SessionHeader& header_specifics,
     base::Time mtime,
     SyncedSession* session_header) {
   if (header_specifics.has_client_name()) {
     session_header->session_name = header_specifics.client_name();
   }
   if (header_specifics.has_device_type()) {
     switch (header_specifics.device_type()) {
-      case sync_pb::SessionHeader_DeviceType_TYPE_WIN:
+      case sync_pb::SyncEnums_DeviceType_TYPE_WIN:
         session_header->device_type = SyncedSession::TYPE_WIN;
         break;
-      case sync_pb::SessionHeader_DeviceType_TYPE_MAC:
+      case sync_pb::SyncEnums_DeviceType_TYPE_MAC:
         session_header->device_type = SyncedSession::TYPE_MACOSX;
         break;
-      case sync_pb::SessionHeader_DeviceType_TYPE_LINUX:
+      case sync_pb::SyncEnums_DeviceType_TYPE_LINUX:
         session_header->device_type = SyncedSession::TYPE_LINUX;
         break;
-      case sync_pb::SessionHeader_DeviceType_TYPE_CROS:
+      case sync_pb::SyncEnums_DeviceType_TYPE_CROS:
         session_header->device_type = SyncedSession::TYPE_CHROMEOS;
         break;
-      case sync_pb::SessionHeader_DeviceType_TYPE_PHONE:
+      case sync_pb::SyncEnums_DeviceType_TYPE_PHONE:
         session_header->device_type = SyncedSession::TYPE_PHONE;
         break;
-      case sync_pb::SessionHeader_DeviceType_TYPE_TABLET:
+      case sync_pb::SyncEnums_DeviceType_TYPE_TABLET:
         session_header->device_type = SyncedSession::TYPE_TABLET;
         break;
-      case sync_pb::SessionHeader_DeviceType_TYPE_OTHER:
+      case sync_pb::SyncEnums_DeviceType_TYPE_OTHER:
         // Intentionally fall-through
       default:
         session_header->device_type = SyncedSession::TYPE_OTHER;
         break;
     }
   }
   session_header->modified_time = mtime;
 }
 
 // Static
@@ skipping 317 matching lines @@
 
 bool SessionModelAssociator::CryptoReadyIfNecessary() {
   // We only access the cryptographer while holding a transaction.
   syncer::ReadTransaction trans(FROM_HERE, sync_service_->GetUserShare());
   const syncer::ModelTypeSet encrypted_types = trans.GetEncryptedTypes();
   return !encrypted_types.Has(SESSIONS) ||
          sync_service_->IsCryptographerReady(&trans);
 }
 
 }  // namespace browser_sync