Sync FileSystem: Add simulated relaunch of DriveFileSyncService on its unit_tests

chrome/browser/sync_file_system/drive_file_sync_service.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_file_system/drive_file_sync_service.h"
 
 #include <algorithm>
 #include <string>
 #include <utility>
 
@@ skipping 269 matching lines @@
       base::Bind(&DriveFileSyncService::DidInitializeMetadataStore,
                  AsWeakPtr(),
                  base::Passed(GetToken(FROM_HERE, TASK_TYPE_DATABASE,
                                        "Metadata database initialization"))));
 }
 
 DriveFileSyncService::~DriveFileSyncService() {
   // Invalidate WeakPtr instances here explicitly to notify TaskToken that we
   // can safely discard the token.
   weak_factory_.InvalidateWeakPtrs();
-  sync_client_->RemoveObserver(this);
+  if (sync_client_)
+    sync_client_->RemoveObserver(this);
   token_.reset();
 
   // Unregister for Drive notifications.
   ProfileSyncService* profile_sync_service =
       ProfileSyncServiceFactory::GetForProfile(profile_);
   if (!profile_sync_service || !push_notification_registered_) {
     return;
   }
 
   // TODO(calvinlo): Revisit this later in Consolidate Drive XMPP Notification
@@ skipping 10 matching lines @@
 // static
 scoped_ptr<DriveFileSyncService> DriveFileSyncService::CreateForTesting(
     Profile* profile,
     const base::FilePath& base_dir,
     scoped_ptr<DriveFileSyncClientInterface> sync_client,
     scoped_ptr<DriveMetadataStore> metadata_store) {
   return make_scoped_ptr(new DriveFileSyncService(
       profile, base_dir, sync_client.Pass(), metadata_store.Pass()));
 }
 
+scoped_ptr<DriveFileSyncClientInterface>
+DriveFileSyncService::DestroyAndPassSyncClientForTesting(
+    scoped_ptr<DriveFileSyncService> sync_service) {
+  return sync_service->sync_client_.Pass();
+}
+
 void DriveFileSyncService::AddServiceObserver(Observer* observer) {
   service_observers_.AddObserver(observer);
 }
 
 void DriveFileSyncService::AddFileStatusObserver(
     FileStatusObserver* observer) {
   file_status_observers_.AddObserver(observer);
 }
 
 void DriveFileSyncService::RegisterOriginForTrackingChanges(
@@ skipping 1485 matching lines @@
         may_have_unfetched_changes_) {
       GURL origin = *pending_batch_sync_origins_.begin();
       pending_batch_sync_origins_.erase(pending_batch_sync_origins_.begin());
       std::string resource_id = metadata_store_->GetResourceIdForOrigin(origin);
       StartBatchSyncForOrigin(origin, resource_id);
     }
     return;
   }
 
   if (may_have_unfetched_changes_ &&
-      !metadata_store_->incremental_sync_origins().empty() &&
-      pending_changes_.empty()) {
+      !metadata_store_->incremental_sync_origins().empty()) {
     FetchChangesForIncrementalSync();
   }
 }
 
 void DriveFileSyncService::FetchChangesForIncrementalSync() {
   scoped_ptr<TaskToken> token(GetToken(FROM_HERE, TASK_TYPE_DRIVE,
                                        "Fetching remote change list"));
   DCHECK(token);
   DCHECK(may_have_unfetched_changes_);
   DCHECK(pending_batch_sync_origins_.empty());
   DCHECK(!metadata_store_->incremental_sync_origins().empty());
-  DCHECK(pending_changes_.empty());
 
   DVLOG(1) << "FetchChangesForIncrementalSync (start_changestamp:"
            << (largest_fetched_changestamp_ + 1) << ")";
 
   sync_client_->ListChanges(
       largest_fetched_changestamp_ + 1,
       base::Bind(&DriveFileSyncService::DidFetchChangesForIncrementalSync,
                  AsWeakPtr(), base::Passed(&token), false));
 
   may_have_unfetched_changes_ = false;
@@ skipping 181 matching lines @@
     DCHECK_EQ(SYNC_ACTION_NONE, action_taken);
     DCHECK_EQ(SYNC_DIRECTION_NONE, direction);
   }
 
   FOR_EACH_OBSERVER(
       FileStatusObserver, file_status_observers_,
       OnFileStatusChanged(url, sync_status, action_taken, direction));
 }
 
 }  // namespace sync_file_system