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

chrome/browser/sync/glue/session_model_associator.h

 // 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.
 
 #ifndef CHROME_BROWSER_SYNC_GLUE_SESSION_MODEL_ASSOCIATOR_H_
 #define CHROME_BROWSER_SYNC_GLUE_SESSION_MODEL_ASSOCIATOR_H_
 #pragma once
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/format_macros.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/scoped_vector.h"
+#include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "base/stringprintf.h"
 #include "base/threading/non_thread_safe.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/sessions/session_id.h"
 #include "chrome/browser/sessions/session_service.h"
 #include "chrome/browser/sessions/session_types.h"
 #include "chrome/browser/sync/glue/model_associator.h"
 #include "chrome/browser/sync/glue/synced_session_tracker.h"
 #include "chrome/browser/sync/glue/synced_tab_delegate.h"
 #include "chrome/browser/sync/glue/synced_window_delegate.h"
 #include "chrome/browser/sync/protocol/session_specifics.pb.h"
 #include "chrome/browser/sync/syncable/model_type.h"
+#include "chrome/browser/sync/weak_handle.h"
 
 class Profile;
 class ProfileSyncService;
 
 namespace sync_api {
 class BaseTransaction;
 class ReadNode;
 class WriteNode;
 class WriteTransaction;
 }  // namespace sync_api
 
 namespace sync_pb {
 class SessionSpecifics;
 }  // namespace sync_pb
 
 namespace browser_sync {
 
 static const char kSessionsTag[] = "google_chrome_sessions";
 
 // Contains all logic for associating the Chrome sessions model and
 // the sync sessions model.
 class SessionModelAssociator
     : public PerDataTypeAssociatorInterface<SyncedTabDelegate, size_t>,
+      public base::SupportsWeakPtr<SessionModelAssociator>,
       public base::NonThreadSafe {
  public:
   // Does not take ownership of sync_service.
   explicit SessionModelAssociator(ProfileSyncService* sync_service);
   SessionModelAssociator(ProfileSyncService* sync_service,
                          bool setup_for_test);
   virtual ~SessionModelAssociator();
 
   // The has_nodes out parameter is set to true if the sync model has
   // nodes other than the permanent tagged nodes.  The method may
@@ skipping 113 matching lines @@
   // Note: a new tab page with back/forward history is valid.
   static bool IsValidSessionTab(const SessionTab& tab);
 
   // Returns the syncable model type.
   static syncable::ModelType model_type() { return syncable::SESSIONS; }
 
   // Testing only. Will cause the associator to call MessageLoop::Quit()
   // when a local change is made, or when timeout_milli occurs, whichever is
   // first.
   void BlockUntilLocalChangeForTest(int64 timeout_milli);
+
+  // Callback for when the session name has been computed.
+  void OnSessionNameInitialized(const std::string name);
+
+#if defined(OS_WIN)
+  // Returns the computer name or the empty string an error occurred.
+  static std::string GetComputerName();
+#endif
+
+#if defined(OS_MACOSX)
+  // Returns the Hardware model name, without trailing numbers, if possible.
+  // See http://www.cocoadev.com/index.pl?MacintoshModels for an example list of
+  // models. If an error occurs trying to read the model, this simply returns
+  // "Unknown".
+  static std::string GetHardwareModelName();
+#endif
+
  private:
   FRIEND_TEST_ALL_PREFIXES(ProfileSyncServiceSessionTest, WriteSessionToNode);
   FRIEND_TEST_ALL_PREFIXES(ProfileSyncServiceSessionTest,
                            WriteFilledSessionToNode);
   FRIEND_TEST_ALL_PREFIXES(ProfileSyncServiceSessionTest,
                            WriteForeignSessionToNode);
   FRIEND_TEST_ALL_PREFIXES(ProfileSyncServiceSessionTest, TabNodePoolEmpty);
   FRIEND_TEST_ALL_PREFIXES(ProfileSyncServiceSessionTest, TabNodePoolNonEmpty);
+  FRIEND_TEST_ALL_PREFIXES(SessionModelAssociatorTest, PopulateSessionHeader);
   FRIEND_TEST_ALL_PREFIXES(SessionModelAssociatorTest, PopulateSessionWindow);
   FRIEND_TEST_ALL_PREFIXES(SessionModelAssociatorTest, PopulateSessionTab);
+  FRIEND_TEST_ALL_PREFIXES(SessionModelAssociatorTest,
+                           InitializeCurrentSessionName);
 
   // Keep all the links to local tab data in one place.
   class TabLinks {
    public:
     // To support usage as second value in maps we need default and copy
     // constructors.
     TabLinks()
         : sync_id_(0),
           session_tab_(NULL),
           tab_(NULL) {}
@@ skipping 108 matching lines @@
   // Build a sync tag from tab_node_id.
   static inline std::string TabIdToTag(
       const std::string machine_tag,
       size_t tab_node_id) {
     return base::StringPrintf("%s %"PRIuS"", machine_tag.c_str(), tab_node_id);
   }
 
   // Initializes the tag corresponding to this machine.
   void InitializeCurrentMachineTag(sync_api::WriteTransaction* trans);
 
+  // Initializes the user visible name for this session
+  void InitializeCurrentSessionName();
+
   // Updates the server data based upon the current client session.  If no node
   // corresponding to this machine exists in the sync model, one is created.
   void UpdateSyncModelDataFromClient();
 
   // Pulls the current sync model from the sync database and returns true upon
   // update of the client model. Will associate any foreign sessions as well as
   // keep track of any local tab nodes, adding them to our free tab node pool.
   bool UpdateAssociationsFromSyncModel(const sync_api::ReadNode& root,
                                        const sync_api::BaseTransaction* trans);
 
   // Fills a tab sync node with data from a TabContents object.
   // (from a local navigation event)
   bool WriteTabContentsToSyncModel(const SyncedWindowDelegate& window,
                                    const SyncedTabDelegate& tab,
                                    const int64 sync_id,
                                    sync_api::WriteTransaction* trans);
 
+  // Used to populate a session header from the session specifics header
+  // provided.
+  static void PopulateSessionHeaderFromSpecifics(
+    const sync_pb::SessionHeader& header_specifics,
+    SyncedSession* session_header);
+
   // Used to populate a session window from the session specifics window
   // provided. Tracks any foreign session data created through |tracker|.
   static void PopulateSessionWindowFromSpecifics(
       const std::string& foreign_session_tag,
       const sync_pb::SessionWindow& window,
       const int64 mtime,
       SessionWindow* session_window,
       SyncedSessionTracker* tracker);
 
   // Used to populate a session tab from the session specifics tab provided.
@@ skipping 37 matching lines @@
                                   const int64 sync_id,
                                   sync_api::WriteTransaction* trans);
 
   // Populates the tab portion of the session specifics.
   void PopulateSessionSpecificsTab(const SessionTab& tab,
                                    sync_pb::SessionTab* session_tab);
 
   // For testing only.
   void QuitLoopForTest();
 
-  // Local client name.
+  // Unique client tag.
   std::string current_machine_tag_;
 
+  // User-visible machine name.
+  std::string current_session_name_;
+
   // Pool of all used/available sync nodes associated with tabs.
   TabNodePool tab_pool_;
 
   // SyncID for the sync node containing all the window information for this
   // client.
   int64 local_session_syncid_;
 
   // Mapping of current open (local) tabs to their sync identifiers.
   TabLinksMap tab_map_;
 
@@ skipping 12 matching lines @@
   // is made.
   bool waiting_for_change_;
   ScopedRunnableMethodFactory<SessionModelAssociator> test_method_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(SessionModelAssociator);
 };
 
 }  // namespace browser_sync
 
 #endif  // CHROME_BROWSER_SYNC_GLUE_SESSION_MODEL_ASSOCIATOR_H_