Rename OperationObserver to OperationDelegate

chrome/browser/chromeos/drive/sync_client.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/chromeos/drive/sync_client.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "chrome/browser/chromeos/drive/drive.pb.h"
 #include "chrome/browser/chromeos/drive/file_cache.h"
 #include "chrome/browser/chromeos/drive/file_system/download_operation.h"
-#include "chrome/browser/chromeos/drive/file_system/operation_observer.h"
+#include "chrome/browser/chromeos/drive/file_system/operation_delegate.h"
 #include "chrome/browser/chromeos/drive/file_system_util.h"
 #include "chrome/browser/chromeos/drive/job_scheduler.h"
 #include "chrome/browser/chromeos/drive/sync/entry_update_performer.h"
 #include "content/public/browser/browser_thread.h"
 #include "google_apis/drive/task_util.h"
 
 using content::BrowserThread;
 
 namespace drive {
 namespace internal {
@@ skipping 107 matching lines @@
   return metadata->GetResourceEntryById(entry.parent_local_id(), parent);
 }
 
 }  // namespace
 
 SyncClient::SyncTask::SyncTask()
     : state(SUSPENDED), context(BACKGROUND), should_run_again(false) {}
 SyncClient::SyncTask::~SyncTask() {}
 
 SyncClient::SyncClient(base::SequencedTaskRunner* blocking_task_runner,
-                       file_system::OperationObserver* observer,
+                       file_system::OperationDelegate* delegate,
                        JobScheduler* scheduler,
                        ResourceMetadata* metadata,
                        FileCache* cache,
                        LoaderController* loader_controller,
                        const base::FilePath& temporary_file_directory)
     : blocking_task_runner_(blocking_task_runner),
-      operation_observer_(observer),
+      operation_delegate_(delegate),
       metadata_(metadata),
       cache_(cache),
       download_operation_(new file_system::DownloadOperation(
           blocking_task_runner,
-          observer,
+          delegate,
           scheduler,
           metadata,
           cache,
           temporary_file_directory)),
       entry_update_performer_(new EntryUpdatePerformer(blocking_task_runner,
-                                                       observer,
+                                                       delegate,
                                                        scheduler,
                                                        metadata,
                                                        cache,
                                                        loader_controller)),
       delay_(base::TimeDelta::FromSeconds(kDelaySeconds)),
       long_delay_(base::TimeDelta::FromSeconds(kLongDelaySeconds)),
       weak_ptr_factory_(this) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
@@ skipping 265 matching lines @@
     case FILE_ERROR_NO_CONNECTION:
       // Run the task again so that we'll retry once the connection is back.
       it->second.should_run_again = true;
       it->second.context = ClientContext(BACKGROUND);
       break;
     case FILE_ERROR_SERVICE_UNAVAILABLE:
       // Run the task again so that we'll retry once the service is back.
       it->second.should_run_again = true;
       it->second.context = ClientContext(BACKGROUND);
       retry_delay = long_delay_;
-      operation_observer_->OnDriveSyncError(
+      operation_delegate_->OnDriveSyncError(
           file_system::DRIVE_SYNC_ERROR_SERVICE_UNAVAILABLE, local_id);
       break;
     default:
-      operation_observer_->OnDriveSyncError(
+      operation_delegate_->OnDriveSyncError(
           file_system::DRIVE_SYNC_ERROR_MISC, local_id);
       LOG(WARNING) << "Failed: type = " << type << ", id = " << local_id
                    << ": " << FileErrorToString(error);
   }
 
   for (size_t i = 0; i < it->second.waiting_callbacks.size(); ++i) {
     base::MessageLoopProxy::current()->PostTask(
         FROM_HERE, base::Bind(it->second.waiting_callbacks[i], error));
   }
   it->second.waiting_callbacks.clear();
@@ skipping 25 matching lines @@
     base::PostTaskAndReplyWithResult(
         blocking_task_runner_,
         FROM_HERE,
         base::Bind(&FileCache::Unpin, base::Unretained(cache_), local_id),
         base::Bind(&util::EmptyFileOperationCallback));
   }
 }
 
 }  // namespace internal
 }  // namespace drive