Rename GData* to Drive* in gdata.proto

chrome/browser/chromeos/gdata/gdata_file_system.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/gdata/gdata_file_system.h"
 
 #include <set>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "base/metrics/histogram.h"
 #include "base/platform_file.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/values.h"
+#include "chrome/browser/chromeos/gdata/drive.pb.h"
 #include "chrome/browser/chromeos/gdata/drive_api_parser.h"
 #include "chrome/browser/chromeos/gdata/drive_service_interface.h"
 #include "chrome/browser/chromeos/gdata/drive_webapps_registry.h"
-#include "chrome/browser/chromeos/gdata/gdata.pb.h"
 #include "chrome/browser/chromeos/gdata/gdata_download_observer.h"
 #include "chrome/browser/chromeos/gdata/gdata_files.h"
 #include "chrome/browser/chromeos/gdata/gdata_protocol_handler.h"
 #include "chrome/browser/chromeos/gdata/gdata_system_service.h"
 #include "chrome/browser/chromeos/gdata/gdata_uploader.h"
 #include "chrome/browser/chromeos/gdata/gdata_util.h"
 #include "chrome/browser/chromeos/gdata/task_util.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_notification_types.h"
@@ skipping 225 matching lines @@
       callback.Run(error, next_feed, result_vec.Pass());
   }
 }
 
 // Helper function for binding |path| to GetEntryInfoWithFilePathCallback and
 // create GetEntryInfoCallback.
 void RunGetEntryInfoWithFilePathCallback(
     const GetEntryInfoWithFilePathCallback& callback,
     const FilePath& path,
     GDataFileError error,
-    scoped_ptr<GDataEntryProto> entry_proto) {
+    scoped_ptr<DriveEntryProto> entry_proto) {
   if (!callback.is_null())
     callback.Run(error, path, entry_proto.Pass());
 }
 
 }  // namespace
 
 // GDataFileSystem::CreateDirectoryParams struct implementation.
 struct GDataFileSystem::CreateDirectoryParams {
   CreateDirectoryParams(const FilePath& created_directory_path,
                         const FilePath& target_directory_path,
@@ skipping 267 matching lines @@
                  callback));
 }
 
 void GDataFileSystem::GetEntryInfoByEntryOnUIThread(
     const GetEntryInfoWithFilePathCallback& callback,
     GDataEntry* entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (entry) {
-    scoped_ptr<GDataEntryProto> entry_proto(new GDataEntryProto);
+    scoped_ptr<DriveEntryProto> entry_proto(new DriveEntryProto);
     entry->ToProtoFull(entry_proto.get());
     CheckLocalModificationAndRun(
         entry_proto.Pass(),
         base::Bind(&RunGetEntryInfoWithFilePathCallback,
                    callback, entry->GetFilePath()));
   } else {
     callback.Run(GDATA_FILE_ERROR_NOT_FOUND,
                  FilePath(),
-                 scoped_ptr<GDataEntryProto>());
+                 scoped_ptr<DriveEntryProto>());
   }
 }
 
 void GDataFileSystem::LoadFeedIfNeeded(const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (directory_service_->origin() == INITIALIZING) {
     // If root feed is not initialized but the initialization process has
     // already started, add an observer to execute the remaining task after
@@ skipping 52 matching lines @@
           local_src_file_path,
           remote_dest_file_path,
           callback));
 }
 
 void GDataFileSystem::TransferFileFromLocalToRemoteAfterGetEntryInfo(
     const FilePath& local_src_file_path,
     const FilePath& remote_dest_file_path,
     const FileOperationCallback& callback,
     GDataFileError error,
-    scoped_ptr<GDataEntryProto> entry_proto) {
+    scoped_ptr<DriveEntryProto> entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (error != GDATA_FILE_OK) {
     callback.Run(error);
     return;
   }
 
   DCHECK(entry_proto.get());
   if (!entry_proto->file_info().is_directory()) {
@@ skipping 99 matching lines @@
           params,
           *file_size,
           *content_type));
 }
 
 void GDataFileSystem::StartFileUploadOnUIThreadAfterGetEntryInfo(
     const StartFileUploadParams& params,
     int64 file_size,
     std::string content_type,
     GDataFileError error,
-    scoped_ptr<GDataEntryProto> entry_proto) {
+    scoped_ptr<DriveEntryProto> entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (entry_proto.get() && !entry_proto->file_info().is_directory())
     error = GDATA_FILE_ERROR_NOT_A_DIRECTORY;
 
   if (error != GDATA_FILE_OK) {
     if (!params.callback.is_null())
       params.callback.Run(error);
     return;
   }
@@ skipping 77 matching lines @@
   DCHECK(result.get());
 
   if (result->first.error != GDATA_FILE_OK) {
     callback.Run(result->first.error);
     return;
   } else if (result->second.error != GDATA_FILE_OK) {
     callback.Run(result->second.error);
     return;
   }
 
-  scoped_ptr<GDataEntryProto> src_file_proto = result->first.proto.Pass();
-  scoped_ptr<GDataEntryProto> dest_parent_proto = result->second.proto.Pass();
+  scoped_ptr<DriveEntryProto> src_file_proto = result->first.proto.Pass();
+  scoped_ptr<DriveEntryProto> dest_parent_proto = result->second.proto.Pass();
 
   if (!dest_parent_proto->file_info().is_directory()) {
     callback.Run(GDATA_FILE_ERROR_NOT_A_DIRECTORY);
     return;
   } else if (src_file_proto->file_info().is_directory()) {
     // TODO(kochi): Implement copy for directories. In the interim,
     // we handle recursive directory copy in the file manager.
     // crbug.com/141596
     callback.Run(GDATA_FILE_ERROR_INVALID_OPERATION);
     return;
@@ skipping 108 matching lines @@
           file_path,
           new_name,
           callback));
 }
 
 void GDataFileSystem::RenameAfterGetEntryInfo(
     const FilePath& file_path,
     const FilePath::StringType& new_name,
     const FileMoveCallback& callback,
     GDataFileError error,
-    scoped_ptr<GDataEntryProto> entry_proto) {
+    scoped_ptr<DriveEntryProto> entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (error != GDATA_FILE_OK) {
     if (!callback.is_null())
       callback.Run(error, file_path);
     return;
   }
   DCHECK(entry_proto.get());
 
   // Drop the .g<something> extension from |new_name| if the file being
@@ skipping 57 matching lines @@
   DCHECK(result.get());
 
   if (result->first.error != GDATA_FILE_OK) {
     callback.Run(result->first.error);
     return;
   } else if (result->second.error != GDATA_FILE_OK) {
     callback.Run(result->second.error);
     return;
   }
 
-  scoped_ptr<GDataEntryProto> dest_parent_proto = result->second.proto.Pass();
+  scoped_ptr<DriveEntryProto> dest_parent_proto = result->second.proto.Pass();
   if (!dest_parent_proto->file_info().is_directory()) {
     callback.Run(GDATA_FILE_ERROR_NOT_A_DIRECTORY);
     return;
   }
 
   // If the file/directory is moved to the same directory, just rename it.
   const FilePath& src_file_path = result->first.path;
   const FilePath& dest_parent_path = result->second.path;
   if (src_file_path.DirName() == dest_parent_path) {
     FileMoveCallback final_file_path_update_callback =
@@ skipping 62 matching lines @@
   DCHECK(result.get());
 
   if (result->first.error != GDATA_FILE_OK) {
     callback.Run(result->first.error);
     return;
   } else if (result->second.error != GDATA_FILE_OK) {
     callback.Run(result->second.error);
     return;
   }
 
-  scoped_ptr<GDataEntryProto> src_proto = result->first.proto.Pass();
-  scoped_ptr<GDataEntryProto> dir_proto = result->second.proto.Pass();
+  scoped_ptr<DriveEntryProto> src_proto = result->first.proto.Pass();
+  scoped_ptr<DriveEntryProto> dir_proto = result->second.proto.Pass();
 
   if (!dir_proto->file_info().is_directory()) {
     callback.Run(GDATA_FILE_ERROR_NOT_A_DIRECTORY);
     return;
   }
 
   const FilePath& file_path = result->first.path;
   const FilePath& dir_path = result->second.path;
   drive_service_->AddResourceToDirectory(
       GURL(dir_proto->content_url()),
@@ skipping 38 matching lines @@
   const FilePath& file_path = result->first.path;
   const FilePath& dir_path = result->second.path;
   if (result->first.error != GDATA_FILE_OK) {
     callback.Run(result->first.error, file_path);
     return;
   } else if (result->second.error != GDATA_FILE_OK) {
     callback.Run(result->second.error, file_path);
     return;
   }
 
-  scoped_ptr<GDataEntryProto> entry_proto = result->first.proto.Pass();
-  scoped_ptr<GDataEntryProto> dir_proto = result->second.proto.Pass();
+  scoped_ptr<DriveEntryProto> entry_proto = result->first.proto.Pass();
+  scoped_ptr<DriveEntryProto> dir_proto = result->second.proto.Pass();
 
   if (!dir_proto->file_info().is_directory()) {
     callback.Run(GDATA_FILE_ERROR_NOT_A_DIRECTORY, file_path);
     return;
   }
 
   drive_service_->RemoveResourceFromDirectory(
       GURL(dir_proto->content_url()),
       GURL(entry_proto->edit_url()),
       entry_proto->resource_id(),
@@ skipping 31 matching lines @@
           file_path,
           is_recursive,
           callback));
 }
 
 void GDataFileSystem::RemoveOnUIThreadAfterGetEntryInfo(
     const FilePath& file_path,
     bool /* is_recursive */,
     const FileOperationCallback& callback,
     GDataFileError error,
-    scoped_ptr<GDataEntryProto> entry_proto) {
+    scoped_ptr<DriveEntryProto> entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (error != GDATA_FILE_OK) {
     if (!callback.is_null()) {
       base::MessageLoopProxy::current()->PostTask(
           FROM_HERE, base::Bind(callback, error));
     }
     return;
   }
 
@@ skipping 117 matching lines @@
                  file_path,
                  is_exclusive,
                  callback));
 }
 
 void GDataFileSystem::OnGetEntryInfoForCreateFile(
     const FilePath& file_path,
     bool is_exclusive,
     const FileOperationCallback& callback,
     GDataFileError result,
-    scoped_ptr<GDataEntryProto> entry_proto) {
+    scoped_ptr<DriveEntryProto> entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   // The |file_path| is invalid. It is an error.
   if (result != GDATA_FILE_ERROR_NOT_FOUND &&
       result != GDATA_FILE_OK) {
     callback.Run(result);
     return;
   }
 
@@ skipping 47 matching lines @@
                  file_path,
                  CreateRelayCallback(get_file_callback),
                  CreateRelayCallback(get_content_callback)));
 }
 
 void GDataFileSystem::OnGetEntryInfoCompleteForGetFileByPath(
     const FilePath& file_path,
     const GetFileCallback& get_file_callback,
     const GetContentCallback& get_content_callback,
     GDataFileError error,
-    scoped_ptr<GDataEntryProto> entry_proto) {
+    scoped_ptr<DriveEntryProto> entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // If |error| == PLATFORM_FILE_OK then |entry_proto| must be valid.
   DCHECK(error != GDATA_FILE_OK ||
          (entry_proto.get() && !entry_proto->resource_id().empty()));
   GetResolvedFileByPath(file_path,
                         get_file_callback,
                         get_content_callback,
                         error,
                         entry_proto.get());
 }
 
 void GDataFileSystem::GetResolvedFileByPath(
     const FilePath& file_path,
     const GetFileCallback& get_file_callback,
     const GetContentCallback& get_content_callback,
     GDataFileError error,
-    const GDataEntryProto* entry_proto) {
+    const DriveEntryProto* entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (entry_proto && !entry_proto->has_file_specific_info())
     error = GDATA_FILE_ERROR_NOT_FOUND;
 
   if (error != GDATA_FILE_OK) {
     if (!get_file_callback.is_null()) {
       MessageLoop::current()->PostTask(
           FROM_HERE,
           base::Bind(get_file_callback,
@@ skipping 270 matching lines @@
 }
 
 void GDataFileSystem::GetEntryInfoByPathOnUIThreadAfterLoad(
     const FilePath& file_path,
     const GetEntryInfoCallback& callback,
     GDataFileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (error != GDATA_FILE_OK) {
-    callback.Run(error, scoped_ptr<GDataEntryProto>());
+    callback.Run(error, scoped_ptr<DriveEntryProto>());
     return;
   }
 
   directory_service_->GetEntryInfoByPath(
       file_path,
       base::Bind(&GDataFileSystem::GetEntryInfoByPathOnUIThreadAfterGetEntry,
                  ui_weak_ptr_,
                  callback));
 }
 
 void GDataFileSystem::GetEntryInfoByPathOnUIThreadAfterGetEntry(
     const GetEntryInfoCallback& callback,
     GDataFileError error,
-    scoped_ptr<GDataEntryProto> entry_proto) {
+    scoped_ptr<DriveEntryProto> entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (error != GDATA_FILE_OK) {
-    callback.Run(error, scoped_ptr<GDataEntryProto>());
+    callback.Run(error, scoped_ptr<DriveEntryProto>());
     return;
   }
   DCHECK(entry_proto.get());
 
   CheckLocalModificationAndRun(entry_proto.Pass(), callback);
 }
 
 void GDataFileSystem::ReadDirectoryByPath(
     const FilePath& file_path,
     const ReadDirectoryWithSettingCallback& callback) {
@@ skipping 24 matching lines @@
 void GDataFileSystem::ReadDirectoryByPathOnUIThreadAfterLoad(
     const FilePath& file_path,
     const ReadDirectoryWithSettingCallback& callback,
     GDataFileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (error != GDATA_FILE_OK) {
     callback.Run(error,
                  hide_hosted_docs_,
-                 scoped_ptr<GDataEntryProtoVector>());
+                 scoped_ptr<DriveEntryProtoVector>());
     return;
   }
 
   directory_service_->ReadDirectoryByPath(
       file_path,
       base::Bind(&GDataFileSystem::ReadDirectoryByPathOnUIThreadAfterRead,
                  ui_weak_ptr_,
                  callback));
 }
 
 void GDataFileSystem::ReadDirectoryByPathOnUIThreadAfterRead(
     const ReadDirectoryWithSettingCallback& callback,
     GDataFileError error,
-    scoped_ptr<GDataEntryProtoVector> entries) {
+    scoped_ptr<DriveEntryProtoVector> entries) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (error != GDATA_FILE_OK) {
     callback.Run(error,
                  hide_hosted_docs_,
-                 scoped_ptr<GDataEntryProtoVector>());
+                 scoped_ptr<DriveEntryProtoVector>());
     return;
   }
   DCHECK(entries.get());  // This is valid for emptry directories too.
 
   callback.Run(GDATA_FILE_OK, hide_hosted_docs_, entries.Pass());
 }
 
 void GDataFileSystem::RequestDirectoryRefresh(const FilePath& file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
@@ skipping 12 matching lines @@
       file_path,
       base::Bind(
           &GDataFileSystem::RequestDirectoryRefreshOnUIThreadAfterGetEntryInfo,
           ui_weak_ptr_,
           file_path));
 }
 
 void GDataFileSystem::RequestDirectoryRefreshOnUIThreadAfterGetEntryInfo(
     const FilePath& file_path,
     GDataFileError error,
-    scoped_ptr<GDataEntryProto> entry_proto) {
+    scoped_ptr<DriveEntryProto> entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (error != GDATA_FILE_OK ||
       !entry_proto->file_info().is_directory()) {
     LOG(ERROR) << "Directory entry not found: " << file_path.value();
     return;
   }
 
   feed_loader_->LoadDirectoryFromServer(
       directory_service_->origin(),
@@ skipping 576 matching lines @@
                  status,
                  content_url,
                  downloaded_file_path,
                  base::Owned(has_enough_space)));
 }
 
 void GDataFileSystem::UnpinIfPinned(
     const std::string& resource_id,
     const std::string& md5,
     bool success,
-    const GDataCacheEntry& cache_entry) {
+    const DriveCacheEntry& cache_entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // TODO(hshi): http://crbug.com/127138 notify when file properties change.
   // This allows file manager to clear the "Available offline" checkbox.
   if (success && cache_entry.is_pinned())
     cache_->UnpinOnUIThread(resource_id, md5, CacheOperationCallback());
 }
 
 void GDataFileSystem::OnFileDownloadedAndSpaceChecked(
     const GetFileFromCacheParams& params,
     GDataErrorCode status,
@@ skipping 561 matching lines @@
                  base::Bind(&GDataFileSystem::OnOpenFileFinished,
                             ui_weak_ptr_,
                             file_path,
                             callback)));
 }
 
 void GDataFileSystem::OnGetEntryInfoCompleteForOpenFile(
     const FilePath& file_path,
     const OpenFileCallback& callback,
     GDataFileError error,
-    scoped_ptr<GDataEntryProto> entry_proto) {
+    scoped_ptr<DriveEntryProto> entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (entry_proto.get() && !entry_proto->has_file_specific_info())
     error = GDATA_FILE_ERROR_NOT_FOUND;
 
   if (error == GDATA_FILE_OK) {
     if (entry_proto->file_specific_info().file_md5().empty() ||
         entry_proto->file_specific_info().is_hosted_document()) {
       // No support for opening a directory or hosted document.
       error = GDATA_FILE_ERROR_INVALID_OPERATION;
@@ skipping 109 matching lines @@
                  base::Bind(&GDataFileSystem::CloseFileOnUIThreadFinalize,
                             ui_weak_ptr_,
                             file_path,
                             callback)));
 }
 
 void GDataFileSystem::CloseFileOnUIThreadAfterGetEntryInfo(
     const FilePath& file_path,
     const FileOperationCallback& callback,
     GDataFileError error,
-    scoped_ptr<GDataEntryProto> entry_proto) {
+    scoped_ptr<DriveEntryProto> entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (entry_proto.get() && !entry_proto->has_file_specific_info())
     error = GDATA_FILE_ERROR_NOT_FOUND;
 
   if (error != GDATA_FILE_OK) {
     callback.Run(error);
     return;
   }
@@ skipping 34 matching lines @@
   // All the invocation of |callback| from operations initiated from CloseFile
   // must go through here. Removes the |file_path| from the remembered set so
   // that subsequent operations can open the file again.
   open_files_.erase(file_path);
 
   // Then invokes the user-supplied callback function.
   callback.Run(result);
 }
 
 void GDataFileSystem::CheckLocalModificationAndRun(
-    scoped_ptr<GDataEntryProto> entry_proto,
+    scoped_ptr<DriveEntryProto> entry_proto,
     const GetEntryInfoCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(entry_proto.get());
   DCHECK(!callback.is_null());
 
   // For entries that will never be cached, use the original entry info as is.
   if (!entry_proto->has_file_specific_info() ||
       entry_proto->file_specific_info().is_hosted_document()) {
     callback.Run(GDATA_FILE_OK, entry_proto.Pass());
     return;
   }
 
   // Checks if the file is cached and modified locally.
   const std::string resource_id = entry_proto->resource_id();
   const std::string md5 = entry_proto->file_specific_info().file_md5();
   cache_->GetCacheEntryOnUIThread(
       resource_id,
       md5,
       base::Bind(
           &GDataFileSystem::CheckLocalModificationAndRunAfterGetCacheEntry,
           ui_weak_ptr_, base::Passed(&entry_proto), callback));
 }
 
 void GDataFileSystem::CheckLocalModificationAndRunAfterGetCacheEntry(
-    scoped_ptr<GDataEntryProto> entry_proto,
+    scoped_ptr<DriveEntryProto> entry_proto,
     const GetEntryInfoCallback& callback,
     bool success,
-    const GDataCacheEntry& cache_entry) {
+    const DriveCacheEntry& cache_entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   // When no dirty cache is found, use the original entry info as is.
   if (!success || !cache_entry.is_dirty()) {
     callback.Run(GDATA_FILE_OK, entry_proto.Pass());
     return;
   }
 
   // Gets the cache file path.
   const std::string& resource_id = entry_proto->resource_id();
   const std::string& md5 = entry_proto->file_specific_info().file_md5();
   cache_->GetFileOnUIThread(
       resource_id,
       md5,
       base::Bind(
           &GDataFileSystem::CheckLocalModificationAndRunAfterGetCacheFile,
           ui_weak_ptr_, base::Passed(&entry_proto), callback));
 }
 
 void GDataFileSystem::CheckLocalModificationAndRunAfterGetCacheFile(
-    scoped_ptr<GDataEntryProto> entry_proto,
+    scoped_ptr<DriveEntryProto> entry_proto,
     const GetEntryInfoCallback& callback,
     GDataFileError error,
     const std::string& resource_id,
     const std::string& md5,
     const FilePath& local_cache_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   // When no dirty cache is found, use the original entry info as is.
   if (error != GDATA_FILE_OK) {
@@ skipping 13 matching lines @@
                  base::Unretained(get_file_info_result)),
       base::Bind(&GDataFileSystem::CheckLocalModificationAndRunAfterGetFileInfo,
                  ui_weak_ptr_,
                  base::Passed(&entry_proto),
                  callback,
                  base::Owned(file_info),
                  base::Owned(get_file_info_result)));
 }
 
 void GDataFileSystem::CheckLocalModificationAndRunAfterGetFileInfo(
-    scoped_ptr<GDataEntryProto> entry_proto,
+    scoped_ptr<DriveEntryProto> entry_proto,
     const GetEntryInfoCallback& callback,
     base::PlatformFileInfo* file_info,
     bool* get_file_info_result) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (!*get_file_info_result) {
-    callback.Run(GDATA_FILE_ERROR_NOT_FOUND, scoped_ptr<GDataEntryProto>());
+    callback.Run(GDATA_FILE_ERROR_NOT_FOUND, scoped_ptr<DriveEntryProto>());
     return;
   }
 
   PlatformFileInfoProto entry_file_info;
   GDataEntry::ConvertPlatformFileInfoToProto(*file_info, &entry_file_info);
   *entry_proto->mutable_file_info() = entry_file_info;
   callback.Run(GDATA_FILE_OK, entry_proto.Pass());
 }
 
 }  // namespace gdata