Only re-enable remote service if the task used the network.

chrome/browser/sync_file_system/drive_backend/sync_engine_initializer.cc

 // Copyright 2013 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_backend/sync_engine_initializer.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/logging.h"
 #include "chrome/browser/drive/drive_api_service.h"
@@ skipping 121 matching lines @@
   if (metadata_database_->HasSyncRoot()) {
     callback.Run(SYNC_STATUS_OK);
     return;
   }
 
   GetAboutResource(callback);
 }
 
 void SyncEngineInitializer::GetAboutResource(
     const SyncStatusCallback& callback) {
+  set_used_network(true);
   drive_service_->GetAboutResource(
       base::Bind(&SyncEngineInitializer::DidGetAboutResource,
                  weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
 void SyncEngineInitializer::DidGetAboutResource(
     const SyncStatusCallback& callback,
     google_apis::GDataErrorCode error,
     scoped_ptr<google_apis::AboutResource> about_resource) {
   cancel_callback_.Reset();
   if (error != google_apis::HTTP_SUCCESS) {
     callback.Run(GDataErrorCodeToSyncStatusCode(error));
     return;
   }
 
   DCHECK(about_resource);
   root_folder_id_ = about_resource->root_folder_id();
   largest_change_id_ = about_resource->largest_change_id();
 
   DCHECK(!root_folder_id_.empty());
   FindSyncRoot(callback);
 }
 
 void SyncEngineInitializer::FindSyncRoot(const SyncStatusCallback& callback) {
   if (find_sync_root_retry_count_++ >= kMaxRetry) {
     callback.Run(SYNC_STATUS_FAILED);
     return;
   }
 
+  set_used_network(true);
   cancel_callback_ = drive_service_->SearchByTitle(
       kSyncRootFolderTitle,
       std::string(), // parent_folder_id
       base::Bind(&SyncEngineInitializer::DidFindSyncRoot,
                  weak_ptr_factory_.GetWeakPtr(),
                  callback));
 }
 
 void SyncEngineInitializer::DidFindSyncRoot(
     const SyncStatusCallback& callback,
@@ skipping 21 matching lines @@
     DCHECK(!root_folder_id_.empty());
     if (!HasNoParents(*entry) && !HasFolderAsParent(*entry, root_folder_id_))
       continue;
 
     if (!sync_root_folder_ || LessOnCreationTime(*entry, *sync_root_folder_)) {
       sync_root_folder_.reset(entry);
       *itr = NULL;
     }
   }
 
+  set_used_network(true);
   // If there are more results, retrieve them.
   if (GetRemainingFileList(
           &cancel_callback_,
           drive_service_, *resource_list,
           base::Bind(&SyncEngineInitializer::DidFindSyncRoot,
                      weak_ptr_factory_.GetWeakPtr(),
                      callback)))
     return;
 
   if (!sync_root_folder_) {
     CreateSyncRoot(callback);
     return;
   }
 
   if (!HasNoParents(*sync_root_folder_)) {
     DetachSyncRoot(callback);
     return;
   }
 
   ListAppRootFolders(callback);
 }
 
 void SyncEngineInitializer::CreateSyncRoot(const SyncStatusCallback& callback) {
   DCHECK(!sync_root_folder_);
+  set_used_network(true);
   cancel_callback_ = drive_service_->AddNewDirectory(
       root_folder_id_, kSyncRootFolderTitle,
       base::Bind(&SyncEngineInitializer::DidCreateSyncRoot,
                  weak_ptr_factory_.GetWeakPtr(),
                  callback));
 }
 
 void SyncEngineInitializer::DidCreateSyncRoot(
     const SyncStatusCallback& callback,
     google_apis::GDataErrorCode error,
     scoped_ptr<google_apis::ResourceEntry> entry) {
   DCHECK(!sync_root_folder_);
   cancel_callback_.Reset();
   if (error != google_apis::HTTP_SUCCESS &&
       error != google_apis::HTTP_CREATED) {
     callback.Run(GDataErrorCodeToSyncStatusCode(error));
     return;
   }
 
   FindSyncRoot(callback);
 }
 
 void SyncEngineInitializer::DetachSyncRoot(const SyncStatusCallback& callback) {
   DCHECK(sync_root_folder_);
+  set_used_network(true);
   cancel_callback_ = drive_service_->RemoveResourceFromDirectory(
       root_folder_id_, GetID(*sync_root_folder_),
       base::Bind(&SyncEngineInitializer::DidDetachSyncRoot,
                  weak_ptr_factory_.GetWeakPtr(),
                  callback));
 }
 
 void SyncEngineInitializer::DidDetachSyncRoot(
     const SyncStatusCallback& callback,
     google_apis::GDataErrorCode error) {
   cancel_callback_.Reset();
   if (error != google_apis::HTTP_SUCCESS) {
     callback.Run(GDataErrorCodeToSyncStatusCode(error));
     return;
   }
+
   ListAppRootFolders(callback);
 }
 
 void SyncEngineInitializer::ListAppRootFolders(
     const SyncStatusCallback& callback) {
   DCHECK(sync_root_folder_);
+  set_used_network(true);
   cancel_callback_ = drive_service_->GetResourceListInDirectory(
       GetID(*sync_root_folder_),
       base::Bind(&SyncEngineInitializer::DidListAppRootFolders,
                  weak_ptr_factory_.GetWeakPtr(),
                  callback));
 }
 
 void SyncEngineInitializer::DidListAppRootFolders(
     const SyncStatusCallback& callback,
     google_apis::GDataErrorCode error,
     scoped_ptr<google_apis::ResourceList> resource_list) {
   cancel_callback_.Reset();
   if (error != google_apis::HTTP_SUCCESS) {
     callback.Run(GDataErrorCodeToSyncStatusCode(error));
     return;
   }
 
   ScopedVector<google_apis::ResourceEntry>* new_entries =
       resource_list->mutable_entries();
   app_root_folders_.insert(app_root_folders_.end(),
                            new_entries->begin(), new_entries->end());
   new_entries->weak_clear();
 
+  set_used_network(true);
   if (GetRemainingFileList(
           &cancel_callback_,
           drive_service_,
           *resource_list,
           base::Bind(&SyncEngineInitializer::DidListAppRootFolders,
                      weak_ptr_factory_.GetWeakPtr(), callback)))
     return;
 
   PopulateDatabase(callback);
 }
@@ skipping 17 matching lines @@
   if (status != SYNC_STATUS_OK) {
     callback.Run(status);
     return;
   }
 
   callback.Run(SYNC_STATUS_OK);
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system