Rename OperationObserver to OperationDelegate

chrome/browser/chromeos/drive/file_system/copy_operation.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/file_system/copy_operation.h"
 
 #include <string>
 
 #include "base/file_util.h"
 #include "base/task_runner_util.h"
 #include "chrome/browser/chromeos/drive/drive.pb.h"
 #include "chrome/browser/chromeos/drive/file_cache.h"
 #include "chrome/browser/chromeos/drive/file_change.h"
 #include "chrome/browser/chromeos/drive/file_system/create_file_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/resource_entry_conversion.h"
 #include "chrome/browser/chromeos/drive/resource_metadata.h"
 #include "chrome/browser/drive/drive_api_util.h"
 #include "content/public/browser/browser_thread.h"
 #include "google_apis/drive/drive_api_parser.h"
 
 using content::BrowserThread;
 
@@ skipping 243 matching lines @@
     return metadata->GetFilePath(local_id, &params->changed_path);
   }
 
   params->location_type = HAS_PARENT;
   return FILE_ERROR_OK;
 }
 
 }  // namespace
 
 CopyOperation::CopyOperation(base::SequencedTaskRunner* blocking_task_runner,
-                             OperationObserver* observer,
+                             OperationDelegate* delegate,
                              JobScheduler* scheduler,
                              internal::ResourceMetadata* metadata,
                              internal::FileCache* cache,
                              const ResourceIdCanonicalizer& id_canonicalizer)
   : blocking_task_runner_(blocking_task_runner),
-    observer_(observer),
+    delegate_(delegate),
     scheduler_(scheduler),
     metadata_(metadata),
     cache_(cache),
     id_canonicalizer_(id_canonicalizer),
     create_file_operation_(new CreateFileOperation(blocking_task_runner,
-                                                   observer,
+                                                   delegate,
                                                    metadata)),
     weak_ptr_factory_(this) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 CopyOperation::~CopyOperation() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 void CopyOperation::Copy(const base::FilePath& src_file_path,
@@ skipping 26 matching lines @@
 void CopyOperation::CopyAfterTryToCopyLocally(
     const CopyParams* params,
     const std::vector<std::string>* updated_local_ids,
     const bool* directory_changed,
     const bool* should_copy_on_server,
     FileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!params->callback.is_null());
 
   for (size_t i = 0; i < updated_local_ids->size(); ++i)
-    observer_->OnEntryUpdatedByOperation((*updated_local_ids)[i]);
+    delegate_->OnEntryUpdatedByOperation((*updated_local_ids)[i]);
 
   if (*directory_changed) {
     FileChange changed_file;
     DCHECK(!params->src_entry.file_info().is_directory());
     changed_file.Update(params->dest_file_path,
                         FileChange::FILE_TYPE_FILE,
                         FileChange::ADD_OR_UPDATE);
-    observer_->OnFileChangedByOperation(changed_file);
+    delegate_->OnFileChangedByOperation(changed_file);
   }
 
   if (error != FILE_ERROR_OK || !*should_copy_on_server) {
     params->callback.Run(error);
     return;
   }
 
   if (params->parent_entry.resource_id().empty()) {
     // Parent entry may be being synced.
-    const bool waiting = observer_->WaitForSyncComplete(
+    const bool waiting = delegate_->WaitForSyncComplete(
         params->parent_entry.local_id(),
         base::Bind(&CopyOperation::CopyAfterParentSync,
                    weak_ptr_factory_.GetWeakPtr(), *params));
     if (!waiting)
       params->callback.Run(FILE_ERROR_NOT_FOUND);
   } else {
     CopyAfterGetParentResourceId(*params, &params->parent_entry, FILE_ERROR_OK);
   }
 }
 
@@ skipping 129 matching lines @@
                            params->parent_resource_id,
                            params->new_title,
                            base::Time(),
                            params->callback);
       break;
     // When |resource_id| has no parent, we just set the new destination folder
     // as the parent, for sharing the document between the original source.
     // This reparenting is already done in LocalWorkForTransferJsonGdocFile().
     case IS_ORPHAN: {
       DCHECK(!params->changed_path.empty());
-      observer_->OnEntryUpdatedByOperation(params->local_id);
+      delegate_->OnEntryUpdatedByOperation(params->local_id);
 
       FileChange changed_file;
       changed_file.Update(
           params->changed_path,
           FileChange::FILE_TYPE_FILE,  // This must be a hosted document.
           FileChange::ADD_OR_UPDATE);
-      observer_->OnFileChangedByOperation(changed_file);
+      delegate_->OnFileChangedByOperation(changed_file);
       params->callback.Run(error);
       break;
     }
     // When the |resource_id| is not in the local metadata, assume it to be a
     // document just now shared on the server but not synced locally.
     // Same as the IS_ORPHAN case, we want to deal the case by setting parent,
     // but this time we need to resort to server side operation.
     case NOT_IN_METADATA:
       scheduler_->UpdateResource(
           params->resource_id,
@@ skipping 62 matching lines @@
     const FileOperationCallback& callback,
     base::FilePath* file_path,
     const ResourceEntry* entry,
     FileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (error == FILE_ERROR_OK) {
     FileChange changed_file;
     changed_file.Update(*file_path, *entry, FileChange::ADD_OR_UPDATE);
-    observer_->OnFileChangedByOperation(changed_file);
+    delegate_->OnFileChangedByOperation(changed_file);
   }
   callback.Run(error);
 }
 
 void CopyOperation::ScheduleTransferRegularFile(
     const base::FilePath& local_src_path,
     const base::FilePath& remote_dest_path,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
@@ skipping 46 matching lines @@
     const base::FilePath& remote_dest_path,
     const ResourceEntry* entry,
     std::string* local_id,
     FileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (error == FILE_ERROR_OK) {
     FileChange changed_file;
     changed_file.Update(remote_dest_path, *entry, FileChange::ADD_OR_UPDATE);
-    observer_->OnFileChangedByOperation(changed_file);
-    observer_->OnEntryUpdatedByOperation(*local_id);
+    delegate_->OnFileChangedByOperation(changed_file);
+    delegate_->OnEntryUpdatedByOperation(*local_id);
   }
   callback.Run(error);
 }
 
 }  // namespace file_system
 }  // namespace drive