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

chrome/browser/sync_file_system/drive_backend/local_to_remote_syncer.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/local_to_remote_syncer.h"
 
 #include "base/callback.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/sequenced_task_runner.h"
@@ skipping 250 matching lines @@
   // Non-conflicting local folder creation to existing remote folder.
   DCHECK_EQ(FILE_KIND_FOLDER, synced_details.file_kind());
   callback.Run(SYNC_STATUS_OK);
 }
 
 void LocalToRemoteSyncer::DeleteRemoteFile(
     const SyncStatusCallback& callback) {
   DCHECK(remote_file_tracker_);
   DCHECK(remote_file_tracker_->has_synced_details());
 
+  set_used_network(true);
   drive_service()->DeleteResource(
       remote_file_tracker_->file_id(),
       remote_file_tracker_->synced_details().etag(),
       base::Bind(&LocalToRemoteSyncer::DidDeleteRemoteFile,
                  weak_ptr_factory_.GetWeakPtr(),
                  callback));
 }
 
 void LocalToRemoteSyncer::DidDeleteRemoteFile(
     const SyncStatusCallback& callback,
@@ skipping 32 matching lines @@
 
 void LocalToRemoteSyncer::DidGetMD5ForUpload(
     const SyncStatusCallback& callback,
     const std::string& local_file_md5) {
   if (local_file_md5 == remote_file_tracker_->synced_details().md5()) {
     // Local file is not changed.
     callback.Run(SYNC_STATUS_OK);
     return;
   }
 
+  set_used_network(true);
   drive_uploader()->UploadExistingFile(
       remote_file_tracker_->file_id(),
       local_path_,
       "application/octet_stream",
       remote_file_tracker_->synced_details().etag(),
       base::Bind(&LocalToRemoteSyncer::DidUploadExistingFile,
                  weak_ptr_factory_.GetWeakPtr(),
                  callback),
       google_apis::ProgressCallback());
 }
@@ skipping 11 matching lines @@
     UpdateRemoteMetadata(callback);
     return;
   }
 
   callback.Run(GDataErrorCodeToSyncStatusCode(error));
 }
 
 void LocalToRemoteSyncer::UpdateRemoteMetadata(
     const SyncStatusCallback& callback) {
   DCHECK(remote_file_tracker_);
+  set_used_network(true);
   drive_service()->GetResourceEntry(
       remote_file_tracker_->file_id(),
       base::Bind(&LocalToRemoteSyncer::DidGetRemoteMetadata,
                  weak_ptr_factory_.GetWeakPtr(),
                  callback,
                  metadata_database()->GetLargestKnownChangeID()));
 }
 
 void LocalToRemoteSyncer::DidGetRemoteMetadata(
     const SyncStatusCallback& callback,
@@ skipping 34 matching lines @@
     callback.Run(status);
     return;
   }
 
   CreateRemoteFolder(callback);
 }
 
 void LocalToRemoteSyncer::UploadNewFile(const SyncStatusCallback& callback) {
   DCHECK(remote_parent_folder_tracker_);
 
+  set_used_network(true);
   base::FilePath title = fileapi::VirtualPath::BaseName(target_path_);
   drive_uploader()->UploadNewFile(
       remote_parent_folder_tracker_->file_id(),
       local_path_,
       title.AsUTF8Unsafe(),
       GetMimeTypeFromTitle(title),
       base::Bind(&LocalToRemoteSyncer::DidUploadNewFile,
                  weak_ptr_factory_.GetWeakPtr(),
                  callback,
                  metadata_database()->GetLargestKnownChangeID()),
@@ skipping 130 matching lines @@
 drive::DriveUploaderInterface* LocalToRemoteSyncer::drive_uploader() {
   return sync_context_->GetDriveUploader();
 }
 
 MetadataDatabase* LocalToRemoteSyncer::metadata_database() {
   return sync_context_->GetMetadataDatabase();
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system