[Sync] Convert SyncSessionSnapshot to a copy-able class.

chrome/browser/sync/glue/sync_backend_host.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 "build/build_config.h"
 
 #include "chrome/browser/sync/glue/sync_backend_host.h"
 
 #include <algorithm>
 #include <map>
@@ skipping 27 matching lines @@
 #include "jingle/notifier/base/notification_method.h"
 #include "jingle/notifier/base/notifier_options.h"
 #include "net/base/host_port_pair.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "sync/engine/model_safe_worker.h"
 #include "sync/internal_api/base_transaction.h"
 #include "sync/internal_api/read_transaction.h"
 #include "sync/notifier/sync_notifier.h"
 #include "sync/protocol/encryption.pb.h"
 #include "sync/protocol/sync.pb.h"
-#include "sync/sessions/session_state.h"
 #include "sync/util/nigori.h"
 
 static const int kSaveChangesIntervalSeconds = 10;
 static const FilePath::CharType kSyncDataFolderName[] =
     FILE_PATH_LITERAL("Sync Data");
 
 typedef TokenService::TokenAvailableDetails TokenAvailableDetails;
 
 typedef GoogleServiceAuthError AuthError;
 
@@ skipping 15 matching lines @@
       public sync_api::SyncManager::Observer {
  public:
   Core(const std::string& name,
        const FilePath& sync_data_folder_path,
        const base::WeakPtr<SyncBackendHost>& backend);
 
   // SyncManager::Observer implementation.  The Core just acts like an air
   // traffic controller here, forwarding incoming messages to appropriate
   // landing threads.
   virtual void OnSyncCycleCompleted(
-      const sessions::SyncSessionSnapshot* snapshot) OVERRIDE;
+      const sessions::SyncSessionSnapshot& snapshot) OVERRIDE;
   virtual void OnInitializationComplete(
       const WeakHandle<JsBackend>& js_backend,
       bool success) OVERRIDE;
   virtual void OnConnectionStatusChange(
       sync_api::ConnectionStatus status) OVERRIDE;
   virtual void OnPassphraseRequired(
       sync_api::PassphraseRequiredReason reason,
       const sync_pb::EncryptedData& pending_keys) OVERRIDE;
   virtual void OnPassphraseAccepted() OVERRIDE;
   virtual void OnBootstrapTokenUpdated(
@@ skipping 512 matching lines @@
 sync_api::UserShare* SyncBackendHost::GetUserShare() const {
   DCHECK(initialized());
   return core_->sync_manager()->GetUserShare();
 }
 
 SyncBackendHost::Status SyncBackendHost::GetDetailedStatus() {
   DCHECK(initialized());
   return core_->sync_manager()->GetDetailedStatus();
 }
 
-const SyncSessionSnapshot* SyncBackendHost::GetLastSessionSnapshot() const {
-  return last_snapshot_.get();
+SyncSessionSnapshot SyncBackendHost::GetLastSessionSnapshot() const {
+  return last_snapshot_;
 }
 
 bool SyncBackendHost::HasUnsyncedItems() const {
   DCHECK(initialized());
   return core_->sync_manager()->HasUnsyncedItems();
 }
 
 bool SyncBackendHost::IsNigoriEnabled() const {
   return registrar_.get() && registrar_->IsNigoriEnabled();
 }
@@ skipping 21 matching lines @@
     NOTREACHED();
   }
 }
 
 void SyncBackendHost::InitCore(const DoInitializeOptions& options) {
   sync_thread_.message_loop()->PostTask(FROM_HERE,
       base::Bind(&SyncBackendHost::Core::DoInitialize, core_.get(), options));
 }
 
 void SyncBackendHost::HandleSyncCycleCompletedOnFrontendLoop(
-    SyncSessionSnapshot* snapshot) {
+    const SyncSessionSnapshot& snapshot) {
   if (!frontend_)
     return;
   DCHECK_EQ(MessageLoop::current(), frontend_loop_);
 
-  last_snapshot_.reset(snapshot);
+  last_snapshot_ = snapshot;
 
-  SDVLOG(1) << "Got snapshot " << snapshot->ToString();
+  SDVLOG(1) << "Got snapshot " << snapshot.ToString();
 
   const syncable::ModelTypeSet to_migrate =
-      snapshot->syncer_status.types_needing_local_migration;
+      snapshot.syncer_status().types_needing_local_migration;
   if (!to_migrate.Empty())
     frontend_->OnMigrationNeededForTypes(to_migrate);
 
   // Process any changes to the datatypes we're syncing.
   // TODO(sync): add support for removing types.
   if (initialized())
     AddExperimentalTypes();
 
   // If we are waiting for a configuration change, check here to see
   // if this sync cycle has initialized all of the types we've been
   // waiting for.
   if (pending_download_state_.get()) {
     const syncable::ModelTypeSet types_to_add =
         pending_download_state_->types_to_add;
     const syncable::ModelTypeSet added_types =
         pending_download_state_->added_types;
     DCHECK(types_to_add.HasAll(added_types));
     const syncable::ModelTypeSet initial_sync_ended =
-        snapshot->initial_sync_ended;
+        snapshot.initial_sync_ended();
     const syncable::ModelTypeSet failed_configuration_types =
         Difference(added_types, initial_sync_ended);
     SDVLOG(1)
         << "Added types: "
         << syncable::ModelTypeSetToString(added_types)
         << ", configured types: "
         << syncable::ModelTypeSetToString(initial_sync_ended)
         << ", failed configuration types: "
         << syncable::ModelTypeSetToString(failed_configuration_types);
 
     if (!failed_configuration_types.Empty() &&
-        snapshot->retry_scheduled) {
+        snapshot.retry_scheduled()) {
       // Inform the caller that download failed but we are retrying.
       if (!pending_download_state_->retry_in_progress) {
         pending_download_state_->retry_callback.Run();
         pending_download_state_->retry_in_progress = true;
       }
       // Nothing more to do.
       return;
     }
 
     scoped_ptr<PendingConfigureDataTypesState> state(
@@ skipping 145 matching lines @@
 
 SyncBackendHost::PendingConfigureDataTypesState::
 PendingConfigureDataTypesState()
     : reason(sync_api::CONFIGURE_REASON_UNKNOWN),
       retry_in_progress(false) {}
 
 SyncBackendHost::PendingConfigureDataTypesState::
 ~PendingConfigureDataTypesState() {}
 
 void SyncBackendHost::Core::OnSyncCycleCompleted(
-    const SyncSessionSnapshot* snapshot) {
+    const SyncSessionSnapshot& snapshot) {
   if (!sync_loop_)
     return;
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   host_.Call(
       FROM_HERE,
       &SyncBackendHost::HandleSyncCycleCompletedOnFrontendLoop,
-      new SyncSessionSnapshot(*snapshot));
+      snapshot);
 }
 
 
 void SyncBackendHost::Core::OnInitializationComplete(
     const WeakHandle<JsBackend>& js_backend,
     bool success) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   host_.Call(
       FROM_HERE,
       &SyncBackendHost::HandleInitializationCompletedOnFrontendLoop,
@@ skipping 540 matching lines @@
       FROM_HERE,
       base::Bind(&SyncBackendHost::Core::DoRefreshNigori,
                  core_.get(), sync_thread_done_callback));
 }
 
 #undef SDVLOG
 
 #undef SLOG
 
 }  // namespace browser_sync