Add cache_guid accessor to UserShare

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>
 
@@ skipping 18 matching lines @@
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_service.h"
 #include "sync/api/sync_error.h"
 #include "sync/api/time.h"
 #include "sync/internal_api/public/base/model_type.h"
 #include "sync/internal_api/public/base/model_type_invalidation_map.h"
 #include "sync/internal_api/public/read_node.h"
 #include "sync/internal_api/public/read_transaction.h"
+#include "sync/internal_api/public/user_share.h"
 #include "sync/internal_api/public/write_node.h"
 #include "sync/internal_api/public/write_transaction.h"
 #include "sync/protocol/session_specifics.pb.h"
-#include "sync/syncable/directory.h"
-#include "sync/syncable/read_transaction.h"
-#include "sync/syncable/write_transaction.h"
 #include "sync/util/get_session_name.h"
 #include "ui/gfx/favicon_size.h"
 #if defined(OS_LINUX)
 #include "base/linux_util.h"
 #elif defined(OS_WIN)
 #include <windows.h>
 #elif defined(OS_ANDROID)
 #include "sync/util/session_utils_android.h"
 #endif
 
@@ skipping 540 matching lines @@
     if (root.InitByTagLookup(syncer::ModelTypeToRootTag(model_type())) !=
             syncer::BaseNode::INIT_OK) {
       return error_handler_->CreateAndUploadError(
           FROM_HERE,
           kNoSessionsFolderError,
           model_type());
     }
 
     // Make sure we have a machine tag.
     if (current_machine_tag_.empty()) {
-      InitializeCurrentMachineTag(&trans);
+      InitializeCurrentMachineTag(sync_service_->GetUserShare());
       // The session name is retrieved asynchronously so it might not come back
       // for the writing of the session. However, we write to the session often
       // enough (on every navigation) that we'll pick it up quickly.
       InitializeCurrentSessionName();
     }
     synced_session_tracker_.SetLocalSessionTag(current_machine_tag_);
     if (!UpdateAssociationsFromSyncModel(root, &trans, &error)) {
       DCHECK(error.IsSet());
       return error;
     }
@@ skipping 54 matching lines @@
   // There is no local model stored with which to disassociate, just notify
   // foreign session handlers.
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_FOREIGN_SESSION_DISABLED,
       content::Source<Profile>(sync_service_->profile()),
       content::NotificationService::NoDetails());
   return syncer::SyncError();
 }
 
 void SessionModelAssociator::InitializeCurrentMachineTag(
-    syncer::WriteTransaction* trans) {
+    syncer::UserShare* share) {
   DCHECK(CalledOnValidThread());
   DCHECK(current_machine_tag_.empty());
   std::string persisted_guid;
   if (pref_service_)
     persisted_guid = pref_service_->GetString(kSyncSessionsGUID);
   if (!persisted_guid.empty()) {
     current_machine_tag_ = persisted_guid;
     DVLOG(1) << "Restoring persisted session sync guid: "
              << persisted_guid;
   } else {
-    syncer::syncable::Directory* dir =
-        trans->GetWrappedWriteTrans()->directory();
     current_machine_tag_ = "session_sync";
 #if defined(OS_ANDROID)
     const std::string android_id = syncer::internal::GetAndroidId();
     // There are reports that sometimes the android_id can't be read. Those
     // are supposed to be fixed as of Gingerbread, but if it happens we fall
     // back to use the same GUID generation as on other platforms.
     current_machine_tag_.append(android_id.empty() ?
-                                    dir->cache_guid() : android_id);
+                                    share->cache_guid() : android_id);
 #else
-    current_machine_tag_.append(dir->cache_guid());
+    current_machine_tag_.append(share->cache_guid());
 #endif
     DVLOG(1) << "Creating session sync guid: " << current_machine_tag_;
     if (pref_service_)
       pref_service_->SetString(kSyncSessionsGUID, current_machine_tag_);
   }
 
   tab_pool_.set_machine_tag(current_machine_tag_);
 }
 
 void SessionModelAssociator::OnSessionNameInitialized(
@@ skipping 599 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