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

sync/engine/sync_scheduler.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 "sync/engine/sync_scheduler.h"
 
 #include <algorithm>
 #include <cstring>
 
 #include "base/bind.h"
@@ skipping 252 matching lines @@
            base::Bind(&SyncScheduler::StartImpl,
                       weak_ptr_factory_.GetWeakPtr(), mode, callback));
 }
 
 void SyncScheduler::SendInitialSnapshot() {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   scoped_ptr<SyncSession> dummy(new SyncSession(session_context_.get(), this,
       SyncSourceInfo(), ModelSafeRoutingInfo(),
       std::vector<ModelSafeWorker*>()));
   SyncEngineEvent event(SyncEngineEvent::STATUS_CHANGED);
-  sessions::SyncSessionSnapshot snapshot(dummy->TakeSnapshot());
-  event.snapshot = &snapshot;
+  event.snapshot = dummy->TakeSnapshot();
   session_context_->NotifyListeners(event);
 }
 
 void SyncScheduler::StartImpl(Mode mode, const base::Closure& callback) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   SDVLOG(2) << "In StartImpl with mode " << GetModeString(mode);
 
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   DCHECK(!session_context_->account_name().empty());
   DCHECK(syncer_.get());
@@ skipping 876 matching lines @@
   SDVLOG(2) << "OnShouldStopSyncingPermanently";
   syncer_->RequestEarlyExit();  // Thread-safe.
   Notify(SyncEngineEvent::STOP_SYNCING_PERMANENTLY);
 }
 
 void SyncScheduler::OnActionableError(
     const sessions::SyncSessionSnapshot& snap) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   SDVLOG(2) << "OnActionableError";
   SyncEngineEvent event(SyncEngineEvent::ACTIONABLE_ERROR);
-  sessions::SyncSessionSnapshot snapshot(snap);
-  event.snapshot = &snapshot;
+  event.snapshot = snap;
   session_context_->NotifyListeners(event);
 }
 
 void SyncScheduler::OnSyncProtocolError(
     const sessions::SyncSessionSnapshot& snapshot) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
-  if (ShouldRequestEarlyExit(snapshot.errors.sync_protocol_error)) {
+  if (ShouldRequestEarlyExit(snapshot.errors().sync_protocol_error)) {
     SDVLOG(2) << "Sync Scheduler requesting early exit.";
     syncer_->RequestEarlyExit();  // Thread-safe.
   }
-  if (IsActionableError(snapshot.errors.sync_protocol_error))
+  if (IsActionableError(snapshot.errors().sync_protocol_error))
     OnActionableError(snapshot);
 }
 
 void SyncScheduler::set_notifications_enabled(bool notifications_enabled) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   session_context_->set_notifications_enabled(notifications_enabled);
 }
 
 base::TimeDelta SyncScheduler::sessions_commit_delay() const {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   return sessions_commit_delay_;
 }
 
 #undef SDVLOG_LOC
 
 #undef SDVLOG
 
 #undef SLOG
 
 #undef ENUM_CASE
 
 }  // browser_sync