drive: Stop returning ResourceEntry from JobScheduler

chrome/browser/chromeos/drive/sync/entry_update_performer.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/chromeos/drive/sync/entry_update_performer.h"
 
 #include "base/callback_helpers.h"
 #include "base/file_util.h"
 #include "chrome/browser/chromeos/drive/change_list_loader.h"
 #include "chrome/browser/chromeos/drive/drive.pb.h"
 #include "chrome/browser/chromeos/drive/file_cache.h"
 #include "chrome/browser/chromeos/drive/file_system/operation_observer.h"
 #include "chrome/browser/chromeos/drive/file_system_util.h"
 #include "chrome/browser/chromeos/drive/job_scheduler.h"
 #include "chrome/browser/chromeos/drive/resource_metadata.h"
 #include "chrome/browser/chromeos/drive/sync/entry_revert_performer.h"
 #include "chrome/browser/chromeos/drive/sync/remove_performer.h"
 #include "content/public/browser/browser_thread.h"
+#include "google_apis/drive/drive_api_parser.h"
 #include "google_apis/drive/gdata_wapi_parser.h"
 
 using content::BrowserThread;
 
 namespace drive {
 namespace internal {
 
 struct EntryUpdatePerformer::LocalState {
   LocalState() : should_content_update(false) {
   }
@@ skipping 81 matching lines @@
       if (error != FILE_ERROR_OK)
         return error;
       break;
   }
   return FILE_ERROR_OK;
 }
 
 FileError FinishUpdate(ResourceMetadata* metadata,
                        FileCache* cache,
                        const std::string& local_id,
-                       scoped_ptr<google_apis::ResourceEntry> resource_entry,
+                       scoped_ptr<google_apis::FileResource> file_resource,
                        base::FilePath* changed_directory) {
   // When creating new entries, update check may add a new entry with the same
   // resource ID before us. If such an entry exists, remove it.
   std::string existing_local_id;
   FileError error = metadata->GetIdByResourceId(
-      resource_entry->resource_id(), &existing_local_id);
+      file_resource->file_id(), &existing_local_id);
   switch (error) {
     case FILE_ERROR_OK:
       if (existing_local_id != local_id) {
         base::FilePath existing_entry_path;
         error = metadata->GetFilePath(existing_local_id, &existing_entry_path);
         if (error != FILE_ERROR_OK)
           return error;
         error = metadata->RemoveEntry(existing_local_id);
         if (error != FILE_ERROR_OK)
           return error;
@@ skipping 15 matching lines @@
   switch (entry.metadata_edit_state()) {
     case ResourceEntry::CLEAN:  // Nothing to do.
     case ResourceEntry::DIRTY:  // Entry was edited again during the update.
       break;
 
     case ResourceEntry::SYNCING:
       entry.set_metadata_edit_state(ResourceEntry::CLEAN);
       break;
   }
   if (!entry.file_info().is_directory())
-    entry.mutable_file_specific_info()->set_md5(resource_entry->file_md5());
-  entry.set_resource_id(resource_entry->resource_id());
+    entry.mutable_file_specific_info()->set_md5(file_resource->md5_checksum());
+  entry.set_resource_id(file_resource->file_id());
   error = metadata->RefreshEntry(entry);
   if (error != FILE_ERROR_OK)
     return error;
 
   // Clear dirty bit unless the file has been edited during update.
   if (entry.file_specific_info().cache_state().is_dirty() &&
       entry.file_specific_info().cache_state().md5() ==
       entry.file_specific_info().md5()) {
     error = cache->ClearDirty(local_id);
     if (error != FILE_ERROR_OK)
@@ skipping 171 matching lines @@
                  context, callback, local_state->entry.local_id(),
                  base::Passed(scoped_ptr<base::ScopedClosureRunner>())));
 }
 
 void EntryUpdatePerformer::UpdateEntryAfterUpdateResource(
     const ClientContext& context,
     const FileOperationCallback& callback,
     const std::string& local_id,
     scoped_ptr<base::ScopedClosureRunner> loader_lock,
     google_apis::GDataErrorCode status,
-    scoped_ptr<google_apis::ResourceEntry> resource_entry) {
+    scoped_ptr<google_apis::FileResource> entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (status == google_apis::HTTP_FORBIDDEN) {
     // Editing this entry is not allowed, revert local changes.
     entry_revert_performer_->RevertEntry(local_id, context, callback);
     return;
   }
 
   FileError error = GDataToFileError(status);
   if (error != FILE_ERROR_OK) {
     callback.Run(error);
     return;
   }
 
   base::FilePath* changed_directory = new base::FilePath;
   base::PostTaskAndReplyWithResult(
       blocking_task_runner_.get(),
       FROM_HERE,
       base::Bind(&FinishUpdate,
-                 metadata_, cache_, local_id, base::Passed(&resource_entry),
+                 metadata_, cache_, local_id, base::Passed(&entry),
                  changed_directory),
       base::Bind(&EntryUpdatePerformer::UpdateEntryAfterFinish,
                  weak_ptr_factory_.GetWeakPtr(), callback,
                  base::Owned(changed_directory)));
 }
 
 void EntryUpdatePerformer::UpdateEntryAfterFinish(
     const FileOperationCallback& callback,
     const base::FilePath* changed_directory,
     FileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (!changed_directory->empty())
     observer_->OnDirectoryChangedByOperation(*changed_directory);
   callback.Run(error);
 }
 
 }  // namespace internal
 }  // namespace drive