Set user-visible machine names and devices types for synced sessions.

chrome/browser/sync/glue/session_model_associator.cc

 // Copyright (c) 2011 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/logging.h"
 #include "base/tracked.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/session_service_factory.h"
 #include "chrome/browser/sync/api/sync_error.h"
 #include "chrome/browser/sync/glue/synced_tab_delegate.h"
 #include "chrome/browser/sync/glue/synced_window_delegate.h"
 #include "chrome/browser/sync/internal_api/read_node.h"
 #include "chrome/browser/sync/internal_api/read_transaction.h"
 #include "chrome/browser/sync/internal_api/write_node.h"
 #include "chrome/browser/sync/internal_api/write_transaction.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/syncable/syncable.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/url_constants.h"
 #include "content/browser/tab_contents/navigation_entry.h"
 #include "content/common/notification_details.h"
 #include "content/common/notification_service.h"
+#if defined(OS_LINUX)
+#include "base/linux_util.h"
+#elif defined(OS_MACOSX)
+#include <sys/sysctl.h>  // sysctlbyname()
+#include "base/sys_info.h"
+#include "base/string_util.h"
+#elif defined(OS_WIN)
+#include <windows.h>
+#endif
 
 namespace browser_sync {
 
 namespace {
 static const char kNoSessionsFolderError[] =
     "Server did not create the top-level sessions node. We "
     "might be running against an out-of-date server.";
 
 // The maximum number of navigations in each direction we care to sync.
 static const int max_sync_navigation_count = 6;
 }  // namespace
 
+std::string SessionModelAssociator::current_machine_name_ = "";

[Nicolas Zea, 2011/08/30 21:29:58]

You can remove this line (default value for a string is empty string anyways).

[Yaron, 2011/08/31 03:26:12]

But since it's static, I need to have a concrete initialization somewhere

[Nicolas Zea, 2011/08/31 18:23:00]

Woops, I didn't read this properly. Yeah, this definitely needs to be a member
variable. I'm pretty sure this won't work in a multi-profile situation with
multiple sync services, especially if we support the users renaming their
sessions.

[Yaron, 2011/08/31 23:23:21]

Done.

+
 SessionModelAssociator::SessionModelAssociator(ProfileSyncService* sync_service)
     : tab_pool_(sync_service),
       local_session_syncid_(sync_api::kInvalidId),
       sync_service_(sync_service),
       setup_for_test_(false),
       waiting_for_change_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(test_method_factory_(this)) {
   DCHECK(CalledOnValidThread());
   DCHECK(sync_service_);
 }
@@ skipping 65 matching lines @@
 }
 
 void SessionModelAssociator::ReassociateWindows(bool reload_tabs) {
   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);
+  header_s->set_client_name(current_machine_name_);
+#if defined(OS_LINUX)
+  header_s->set_device_type(sync_pb::SessionHeader_DeviceType_TYPE_LINUX);
+#elif defined(OS_MACOSX)
+  header_s->set_device_type(sync_pb::SessionHeader_DeviceType_TYPE_MAC);
+#elif defined(OS_WIN)
+  header_s->set_device_type(sync_pb::SessionHeader_DeviceType_TYPE_WIN);
+#elif defined(OS_CHROMEOS)
+  header_s->set_device_type(sync_pb::SessionHeader_DeviceType_TYPE_CROS);
+#else
+  header_s->set_device_type(sync_pb::SessionHeader_DeviceType_TYPE_OTHER);
+#endif
 
   size_t window_num = 0;
   std::set<SyncedWindowDelegate*> windows =
       SyncedWindowDelegate::GetSyncedWindowDelegates();
   current_session->windows.reserve(windows.size());
   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
@@ skipping 284 matching lines @@
   {
     sync_api::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare());
 
     sync_api::ReadNode root(&trans);
     if (!root.InitByTagLookup(kSessionsTag)) {
       error->Reset(FROM_HERE, kNoSessionsFolderError, model_type());
       return false;
     }
 
     // Make sure we have a machine tag.
-    if (current_machine_tag_.empty())
+    if (current_machine_tag_.empty()) {
       InitializeCurrentMachineTag(&trans);
+      InitializeCurrentMachineName();
+    }
     synced_session_tracker_.SetLocalSessionTag(current_machine_tag_);
     if (!UpdateAssociationsFromSyncModel(root, &trans)) {
       error->Reset(FROM_HERE,
                    "Failed to update associations from sync",
                    model_type());
       return false;
     }
 
     if (local_session_syncid_ == sync_api::kInvalidId) {
       // The sync db didn't have a header node for us, we need to create one.
@@ skipping 16 matching lines @@
   VLOG(1) << "Session models associated.";
 
   return true;
 }
 
 bool SessionModelAssociator::DisassociateModels(SyncError* error) {
   DCHECK(CalledOnValidThread());
   synced_session_tracker_.clear();
   tab_map_.clear();
   tab_pool_.clear();
   local_session_syncid_ = sync_api::kInvalidId;

[Nicolas Zea, 2011/08/30 21:29:58]

Should probably clear current_machine_name and current_machine_tag here.

[Yaron, 2011/08/31 03:26:12]

I cleared current_machine_tag_ but not current_machine_name_. The reason being
that the latter is static and doesn't need to be tied to an instance of a SMA,
but we lazily initialize it when we eventually do need it. If you'd prefer, I
can make it a member and clear it out too.

[Nicolas Zea, 2011/08/31 18:23:00]

See above comment.

[Yaron, 2011/08/31 23:23:21]

Done.

 
   // There is no local model stored with which to disassociate, just notify
   // foreign session handlers.
   NotificationService::current()->Notify(
       chrome::NOTIFICATION_FOREIGN_SESSION_DISABLED,
       NotificationService::AllSources(),
       NotificationService::NoDetails());
   return true;
 }
 
 void SessionModelAssociator::InitializeCurrentMachineTag(
     sync_api::WriteTransaction* trans) {
   DCHECK(CalledOnValidThread());
   syncable::Directory* dir = trans->GetWrappedWriteTrans()->directory();
 
   // TODO(zea): We need a better way of creating a machine tag. The directory

[Nicolas Zea, 2011/08/30 21:29:58]

This TODO no longer applies.

[Yaron, 2011/08/31 03:26:12]

Well not entirely. The last bit of being human-readable goes away but the
comment about starting/stopping Chrome still applies

[Nicolas Zea, 2011/08/31 18:23:00]

Tim and I have chatted about this before and we're not planning on changing it.
The idea is to eventually support users deleting stale sessions (for example the
laptop run over by a truck scenario), which should take care of this. So we can
just get rid of the TODO entirely.

[Yaron, 2011/08/31 23:23:21]

Done.

   // kernel's cache_guid changes every time syncing is turned on and off. This
   // will result in session's associated with stale machine tags persisting on
   // the server since that tag will not be reused. Eventually this should
   // become some string identifiable to the user. (Home, Work, Laptop, etc.)
   // See issue at http://crbug.com/59672
   current_machine_tag_ = "session_sync";
   current_machine_tag_.append(dir->cache_guid());
   VLOG(1) << "Creating machine tag: " << current_machine_tag_;
   tab_pool_.set_machine_tag(current_machine_tag_);
 }
 
+// Static
+void SessionModelAssociator::InitializeCurrentMachineName() {
+#if defined(OS_LINUX)
+  current_machine_name_ = base::GetLinuxDistro();

[Nicolas Zea, 2011/08/30 21:29:58]

should probably check for the "Unknown" case and replace it with "Linux".

[Yaron, 2011/08/31 03:26:12]

Done

+#elif defined(OS_MACOSX)
+  char modelBuffer[256];
+  size_t length = sizeof(modelBuffer);
+  if (!sysctlbyname("hw.model", modelBuffer, &length, NULL, 0)) {

[Nicolas Zea, 2011/08/30 21:29:58]

I'm not familiar with these API's, so my main concern here is whether they may
block on file i/o in some way, leading to jank (Thakis may be a good reviewer to
verify this). Also, I wonder if this functionality (as well as the windows call
below) are better off as methods in base::SysInfo. Something like GetOSXHwModel
and GetWinComputerName.

[Yaron, 2011/08/31 03:26:12]

Split off GetComputerName to win_util and GetHardwareModelName to mac_util and
I'll add the relevant owners to check. I didn't add it to base:SysInfo because
we're intentionally grabbing different values for different platforms.

+    for (size_t i = 0; i < length; i++) {
+      if (IsAsciiDigit(modelBuffer[i])) {
+        current_machine_name_ = std::string(modelBuffer, 0, i);
+        return;
+      }
+    }
+    // If we didn't find a number in the string, Just use Mac OS X.

[Nicolas Zea, 2011/08/30 21:29:58]

Why not just use the full string?

[Yaron, 2011/08/31 03:26:12]

Hmm. I suppose that could be better

+    current_machine_name_ = base::SysInfo::OperatingSystemName();
+  } else {
+    // Can't read hardware model. Just use Mac OS X.
+    current_machine_name_ = base::SysInfo::OperatingSystemName();
+  }
+#elif defined(OS_WIN)
+  char computer_name[MAX_COMPUTERNAME_LENGTH + 1];
+  DWORD size = sizeof(computer_name);
+  if (GetComputerNameA(computer_name, &size)) {
+    current_machine_name_ = computer_name;
+  } else {
+    current_machine_name_ = "Windows";
+  }
+#elif defined(OS_CHROMEOS)
+  current_machine_name_ = "Chromebook";
+#endif

[Nicolas Zea, 2011/08/30 21:29:58]

else "Unknown OS"

[Yaron, 2011/08/31 03:26:12]

I added a catch-all case instead (because it also handles errors from
platform-specific codepaths)

+}
+
+
 bool SessionModelAssociator::UpdateAssociationsFromSyncModel(
     const sync_api::ReadNode& root,
     const sync_api::BaseTransaction* trans) {
   DCHECK(CalledOnValidThread());
 
   // Iterate through the nodes and associate any foreign sessions.
   int64 id = root.GetFirstChildId();
   while (id != sync_api::kInvalidId) {
     sync_api::ReadNode sync_node(trans);
     if (!sync_node.InitByIdLookup(id)) {
@@ skipping 48 matching lines @@
   if (specifics.has_header()) {
     // Read in the header data for this foreign session.
     // Header data contains window information and ordered tab id's for each
     // window.
 
     // Load (or create) the SyncedSession object for this client.
     SyncedSession* foreign_session =
         synced_session_tracker_.GetSession(foreign_session_tag);
 
     const sync_pb::SessionHeader& header = specifics.header();
+    PopulateSessionHeaderFromSpecifics(header, foreign_session);
     foreign_session->windows.reserve(header.window_size());
     VLOG(1) << "Associating " << foreign_session_tag << " with " <<
         header.window_size() << " windows.";
     size_t i;
     for (i = 0; i < static_cast<size_t>(header.window_size()); ++i) {
       if (i >= foreign_session->windows.size()) {
         // This a new window, create it.
         foreign_session->windows.push_back(new SessionWindow());
       }
       const sync_pb::SessionWindow& window_s = header.window(i);
@@ skipping 24 matching lines @@
   return true;
 }
 
 void SessionModelAssociator::DisassociateForeignSession(
     const std::string& foreign_session_tag) {
   DCHECK(CalledOnValidThread());
   synced_session_tracker_.DeleteSession(foreign_session_tag);
 }
 
 // Static
+void SessionModelAssociator::PopulateSessionHeaderFromSpecifics(
+    const sync_pb::SessionHeader& header_specifics,
+    SyncedSession* session_header) {
+  if (header_specifics.has_client_name()) {
+    session_header->client_name = header_specifics.client_name();
+  }
+  if (header_specifics.has_device_type()) {
+    switch (header_specifics.device_type()) {
+      case sync_pb::SessionHeader_DeviceType_TYPE_WIN:
+        session_header->device_type = SyncedSession::TYPE_WIN;
+        break;
+      case sync_pb::SessionHeader_DeviceType_TYPE_MAC:
+        session_header->device_type = SyncedSession::TYPE_MAC;
+        break;
+      case sync_pb::SessionHeader_DeviceType_TYPE_LINUX:
+        session_header->device_type = SyncedSession::TYPE_LINUX;
+        break;
+      case sync_pb::SessionHeader_DeviceType_TYPE_CROS:
+        session_header->device_type = SyncedSession::TYPE_CROS;
+        break;
+      case sync_pb::SessionHeader_DeviceType_TYPE_OTHER:
+        // Intentionally fall-through
+      default:
+        session_header->device_type = SyncedSession::TYPE_OTHER;
+        break;
+    }
+  }
+}
+
+// Static
 void SessionModelAssociator::PopulateSessionWindowFromSpecifics(
     const std::string& session_tag,
     const sync_pb::SessionWindow& specifics,
     int64 mtime,
     SessionWindow* session_window,
     SyncedSessionTracker* tracker) {
   if (specifics.has_window_id())
     session_window->window_id.set_id(specifics.window_id());
   if (specifics.has_selected_tab_index())
     session_window->selected_tab_index = specifics.selected_tab_index();
@@ skipping 452 matching lines @@
 bool SessionModelAssociator::CryptoReadyIfNecessary() {
   // We only access the cryptographer while holding a transaction.
   sync_api::ReadTransaction trans(FROM_HERE, sync_service_->GetUserShare());
   syncable::ModelTypeSet encrypted_types;
   encrypted_types = sync_api::GetEncryptedTypes(&trans);
   return encrypted_types.count(syncable::SESSIONS) == 0 ||
          sync_service_->IsCryptographerReady(&trans);
 }
 
 }  // namespace browser_sync