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

chrome/browser/sync/profile_sync_service_harness.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/profile_sync_service_harness.h"
 
 #include <cstddef>
 #include <iterator>
 #include <ostream>
 #include <set>
@@ skipping 319 matching lines @@
       }
       break;
     }
     case WAITING_FOR_ENCRYPTION: {
       DVLOG(1) << GetClientInfoString("WAITING_FOR_ENCRYPTION");
       // The correctness of this if condition may depend on the ordering of its
       // sub-expressions.  See crbug.com/98607, crbug.com/95619.
       // TODO(rlarocque): Figure out a less brittle way of detecting this.
       if (IsTypeEncrypted(waiting_for_encryption_type_) &&
           IsFullySynced() &&
-          GetLastSessionSnapshot()->num_encryption_conflicts == 0) {
+          GetLastSessionSnapshot().num_encryption_conflicts() == 0) {
         // Encryption is now complete for the the type in which we were waiting.
         SignalStateCompleteWithNextState(FULLY_SYNCED);
         break;
       }
       break;
     }
     case WAITING_FOR_SYNC_CONFIGURATION: {
       DVLOG(1) << GetClientInfoString("WAITING_FOR_SYNC_CONFIGURATION");
       if (service()->ShouldPushChanges()) {
         // The Datatype manager is configured and sync is fully initialized.
         SignalStateCompleteWithNextState(FULLY_SYNCED);
       }
       break;
     }
     case WAITING_FOR_SYNC_DISABLED: {
       DVLOG(1) << GetClientInfoString("WAITING_FOR_SYNC_DISABLED");
       if (service()->HasSyncSetupCompleted() == false) {
         // Sync has been disabled.
         SignalStateCompleteWithNextState(SYNC_DISABLED);
       }
       break;
     }
     case WAITING_FOR_EXPONENTIAL_BACKOFF_VERIFICATION: {
       DVLOG(1) << GetClientInfoString(
           "WAITING_FOR_EXPONENTIAL_BACKOFF_VERIFICATION");
-      const browser_sync::sessions::SyncSessionSnapshot *snap =
-          GetLastSessionSnapshot();
-      CHECK(snap);
-      retry_verifier_.VerifyRetryInterval(*snap);
+      const SyncSessionSnapshot& snap = GetLastSessionSnapshot();
+      retry_verifier_.VerifyRetryInterval(snap);
       if (retry_verifier_.done()) {
         // Retry verifier is done verifying exponential backoff.
         SignalStateCompleteWithNextState(WAITING_FOR_NOTHING);
       }
       break;
     }
     case WAITING_FOR_MIGRATION_TO_START: {
       DVLOG(1) << GetClientInfoString("WAITING_FOR_MIGRATION_TO_START");
       if (HasPendingBackendMigration()) {
         // There are pending migrations. Wait for them.
@@ skipping 193 matching lines @@
 
 bool ProfileSyncServiceHarness::AwaitSyncDisabled(const std::string& reason) {
   DCHECK(service()->HasSyncSetupCompleted());
   DCHECK_NE(wait_state_, SYNC_DISABLED);
   wait_state_ = WAITING_FOR_SYNC_DISABLED;
   AwaitStatusChangeWithTimeout(kLiveSyncOperationTimeoutMs, reason);
   return wait_state_ == SYNC_DISABLED;
 }
 
 bool ProfileSyncServiceHarness::AwaitExponentialBackoffVerification() {
-  const browser_sync::sessions::SyncSessionSnapshot *snap =
-      GetLastSessionSnapshot();
-  CHECK(snap);
-  retry_verifier_.Initialize(*snap);
+  const SyncSessionSnapshot& snap = GetLastSessionSnapshot();
+  retry_verifier_.Initialize(snap);
   wait_state_ = WAITING_FOR_EXPONENTIAL_BACKOFF_VERIFICATION;
   AwaitStatusChangeWithTimeout(kExponentialBackoffVerificationTimeoutMs,
       "Verify Exponential backoff");
   return (retry_verifier_.Succeeded());
 }
 
 bool ProfileSyncServiceHarness::AwaitActionableError() {
   ProfileSyncService::Status status = GetStatus();
   CHECK(status.sync_protocol_error.action == browser_sync::UNKNOWN_ACTION);
   wait_state_ = WAITING_FOR_ACTIONABLE_ERROR;
@@ skipping 150 matching lines @@
 }
 
 ProfileSyncService::Status ProfileSyncServiceHarness::GetStatus() {
   DCHECK(service() != NULL) << "GetStatus(): service() is NULL.";
   return service()->QueryDetailedSyncStatus();
 }
 
 // We use this function to share code between IsFullySynced and IsDataSynced
 // while ensuring that all conditions are evaluated using on the same snapshot.
 bool ProfileSyncServiceHarness::IsDataSyncedImpl(
-    const browser_sync::sessions::SyncSessionSnapshot *snap) {
-  return snap &&
-      snap->num_simple_conflicts == 0 &&
-      ServiceIsPushingChanges() &&
-      GetStatus().notifications_enabled &&
-      !service()->HasUnsyncedItems() &&
-      !snap->has_more_to_sync &&
-      !HasPendingBackendMigration();
+    const SyncSessionSnapshot& snap) {
+  return snap.num_simple_conflicts() == 0 &&
+         ServiceIsPushingChanges() &&
+         GetStatus().notifications_enabled &&
+         !service()->HasUnsyncedItems() &&
+         !snap.has_more_to_sync() &&
+         !HasPendingBackendMigration();
 }
 
 bool ProfileSyncServiceHarness::IsDataSynced() {
   if (service() == NULL) {
     DVLOG(1) << GetClientInfoString("IsDataSynced(): false");
     return false;
   }
 
-  const SyncSessionSnapshot* snap = GetLastSessionSnapshot();
+  const SyncSessionSnapshot& snap = GetLastSessionSnapshot();
   bool is_data_synced = IsDataSyncedImpl(snap);
 
   DVLOG(1) << GetClientInfoString(
       is_data_synced ? "IsDataSynced: true" : "IsDataSynced: false");
   return is_data_synced;
 }
 
 bool ProfileSyncServiceHarness::IsFullySynced() {
   if (service() == NULL) {
     DVLOG(1) << GetClientInfoString("IsFullySynced: false");
     return false;
   }
-  const SyncSessionSnapshot* snap = GetLastSessionSnapshot();
-  // snap->unsynced_count == 0 is a fairly reliable indicator of whether or not
+  const SyncSessionSnapshot& snap = GetLastSessionSnapshot();
+  // snap.unsynced_count() == 0 is a fairly reliable indicator of whether or not
   // our timestamp is in sync with the server.
   bool is_fully_synced = IsDataSyncedImpl(snap) &&
-      snap->unsynced_count == 0;
+      snap.unsynced_count() == 0;
 
   DVLOG(1) << GetClientInfoString(
       is_fully_synced ? "IsFullySynced: true" : "IsFullySynced: false");
   return is_fully_synced;
 }
 
 bool ProfileSyncServiceHarness::HasPendingBackendMigration() {
   browser_sync::BackendMigrator* migrator =
       service()->GetBackendMigratorForTest();
   return migrator && migrator->state() != browser_sync::BackendMigrator::IDLE;
@@ skipping 48 matching lines @@
                  << partner->profile_debug_name_
                  << " partner timestamp = "
                  << partner_timestamp_base64;
       }
       return false;
     }
   }
   return true;
 }
 
-const SyncSessionSnapshot*
-    ProfileSyncServiceHarness::GetLastSessionSnapshot() const {
+SyncSessionSnapshot ProfileSyncServiceHarness::GetLastSessionSnapshot() const {
   DCHECK(service_ != NULL) << "Sync service has not yet been set up.";
   if (service_->sync_initialized()) {
     return service_->GetLastSessionSnapshot();
   }
-  return NULL;
+  return SyncSessionSnapshot();
 }
 
 bool ProfileSyncServiceHarness::EnableSyncForDatatype(
     syncable::ModelType datatype) {
   DVLOG(1) << GetClientInfoString(
       "EnableSyncForDatatype("
       + std::string(syncable::ModelTypeToString(datatype)) + ")");
 
   if (wait_state_ == SYNC_DISABLED) {
     return SetupSync(syncable::ModelTypeSet(datatype));
@@ skipping 92 matching lines @@
 
   service()->DisableForUser();
   wait_state_ = SYNC_DISABLED;
   DVLOG(1) << "DisableSyncForAllDatatypes(): Disabled sync for all "
            << "datatypes on " << profile_debug_name_;
   return true;
 }
 
 std::string ProfileSyncServiceHarness::GetUpdatedTimestamp(
     syncable::ModelType model_type) {
-  const SyncSessionSnapshot* snap = GetLastSessionSnapshot();
-  DCHECK(snap != NULL) << "GetUpdatedTimestamp(): Sync snapshot is NULL.";
-  return snap->download_progress_markers[model_type];
+  const SyncSessionSnapshot& snap = GetLastSessionSnapshot();
+  return snap.download_progress_markers()[model_type];
 }
 
 std::string ProfileSyncServiceHarness::GetClientInfoString(
     const std::string& message) {
   std::stringstream os;
   os << profile_debug_name_ << ": " << message << ": ";
   if (service()) {
-    const SyncSessionSnapshot* snap = GetLastSessionSnapshot();
+    const SyncSessionSnapshot& snap = GetLastSessionSnapshot();
     const ProfileSyncService::Status& status = GetStatus();
-    if (snap) {
-      // Capture select info from the sync session snapshot and syncer status.
-      os << "has_more_to_sync: "
-         << snap->has_more_to_sync
-         << ", has_unsynced_items: "
-         << service()->HasUnsyncedItems()
-         << ", unsynced_count: "
-         << snap->unsynced_count
-         << ", encryption conflicts: "
-         << snap->num_encryption_conflicts
-         << ", hierarchy conflicts: "
-         << snap->num_hierarchy_conflicts
-         << ", simple conflicts: "
-         << snap->num_simple_conflicts
-         << ", server conflicts: "
-         << snap->num_server_conflicts
-         << ", num_updates_downloaded : "
-         << snap->syncer_status.num_updates_downloaded_total
-         << ", passphrase_required_reason: "
-         << sync_api::PassphraseRequiredReasonToString(
-             service()->passphrase_required_reason())
-         << ", notifications_enabled: "
-         << status.notifications_enabled
-         << ", service_is_pushing_changes: "
-         << ServiceIsPushingChanges()
-         << ", has_pending_backend_migration: "
-         << HasPendingBackendMigration();
-    } else {
-      os << "Sync session snapshot not available";
-    }
+    // Capture select info from the sync session snapshot and syncer status.
+    os << "has_more_to_sync: "
+       << snap.has_more_to_sync()
+       << ", has_unsynced_items: "
+       << service()->HasUnsyncedItems()
+       << ", unsynced_count: "
+       << snap.unsynced_count()
+       << ", encryption conflicts: "
+       << snap.num_encryption_conflicts()
+       << ", hierarchy conflicts: "
+       << snap.num_hierarchy_conflicts()
+       << ", simple conflicts: "
+       << snap.num_simple_conflicts()
+       << ", server conflicts: "
+       << snap.num_server_conflicts()
+       << ", num_updates_downloaded : "
+       << snap.syncer_status().num_updates_downloaded_total
+       << ", passphrase_required_reason: "
+       << sync_api::PassphraseRequiredReasonToString(
+           service()->passphrase_required_reason())
+       << ", notifications_enabled: "
+       << status.notifications_enabled
+       << ", service_is_pushing_changes: "
+       << ServiceIsPushingChanges()
+       << ", has_pending_backend_migration: "
+       << HasPendingBackendMigration();
   } else {
     os << "Sync service not available";
   }
   return os.str();
 }
 
 // TODO(zea): Rename this EnableEncryption, since we no longer turn on
 // encryption for individual types but for all.
 bool ProfileSyncServiceHarness::EnableEncryptionForType(
     syncable::ModelType type) {
@@ skipping 15 matching lines @@
   return WaitForTypeEncryption(type);
 }
 
 bool ProfileSyncServiceHarness::WaitForTypeEncryption(
     syncable::ModelType type) {
   // The correctness of this if condition depends on the ordering of its
   // sub-expressions.  See crbug.com/95619.
   // TODO(rlarocque): Figure out a less brittle way of detecting this.
   if (IsTypeEncrypted(type) &&
       IsFullySynced() &&
-      GetLastSessionSnapshot()->num_encryption_conflicts == 0) {
+      GetLastSessionSnapshot().num_encryption_conflicts() == 0) {
     // Encryption is already complete for |type|; do not wait.
     return true;
   }
 
   std::string reason = "Waiting for encryption.";
   wait_state_ = WAITING_FOR_ENCRYPTION;
   waiting_for_encryption_type_ = type;
   if (!AwaitStatusChangeWithTimeout(kLiveSyncOperationTimeoutMs, reason)) {
     LOG(ERROR) << "Did not receive EncryptionComplete notification after"
                << kLiveSyncOperationTimeoutMs / 1000
@@ skipping 19 matching lines @@
   service_->GetDataTypeControllerStates(&state_map);
   return (state_map.count(type) != 0 &&
           state_map[type] == browser_sync::DataTypeController::RUNNING);
 }
 
 bool ProfileSyncServiceHarness::IsTypePreferred(syncable::ModelType type) {
   return service_->GetPreferredDataTypes().Has(type);
 }
 
 size_t ProfileSyncServiceHarness::GetNumEntries() const {
-  return GetLastSessionSnapshot()->num_entries;
+  return GetLastSessionSnapshot().num_entries();
 }
 
 size_t ProfileSyncServiceHarness::GetNumDatatypes() const {
   browser_sync::DataTypeController::StateMap state_map;
   service_->GetDataTypeControllerStates(&state_map);
   return state_map.size();
 }
 
 std::string ProfileSyncServiceHarness::GetServiceStatus() {
   DictionaryValue value;
   sync_ui_util::ConstructAboutInformation(service_, &value);
   std::string service_status;
   base::JSONWriter::WriteWithOptions(&value,
                                      base::JSONWriter::OPTIONS_PRETTY_PRINT,
                                      &service_status);
   return service_status;
 }