gdata: Remove use of FindEntryByPathAsync() from gdata_file_system_proxy.cc

chrome/browser/chromeos/gdata/gdata_file_system_proxy.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_proxy.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/platform_file.h"
 #include "base/string_util.h"
 #include "base/values.h"
 #include "content/public/browser/browser_thread.h"
+#include "chrome/browser/chromeos/gdata/gdata.pb.h"
 #include "chrome/browser/chromeos/gdata/gdata_system_service.h"
 #include "chrome/browser/chromeos/gdata/gdata_file_system.h"
 #include "webkit/blob/shareable_file_reference.h"
 #include "webkit/fileapi/file_system_file_util_proxy.h"
 #include "webkit/fileapi/file_system_types.h"
 #include "webkit/fileapi/file_system_util.h"
 
 using base::MessageLoopProxy;
 using content::BrowserThread;
 using fileapi::FileSystemOperationInterface;
@@ skipping 24 matching lines @@
         BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE));
   }
 
   callback.Run(error, file_info, local_path, file_ref);
 }
 
 }  // namespace
 
 namespace gdata {
 
-base::FileUtilProxy::Entry GDataEntryToFileUtilProxyEntry(
-    const GDataEntry& gdata_entry) {
+base::FileUtilProxy::Entry GDataEntryProtoToFileUtilProxyEntry(
+    const GDataEntryProto& proto) {
+  base::PlatformFileInfo file_info;
+  GDataEntry::ConvertProtoToPlatformFileInfo(proto.file_info(), &file_info);
+
   base::FileUtilProxy::Entry entry;
-  entry.is_directory = gdata_entry.file_info().is_directory;
-
-  // TODO(zelidrag): Add file name modification logic to enforce uniquness of
-  // file paths across this file system.
-  entry.name = gdata_entry.file_name();
-
-  entry.size = gdata_entry.file_info().size;
-  entry.last_modified_time = gdata_entry.file_info().last_modified;
+  entry.name = proto.file_name();
+  entry.is_directory = file_info.is_directory;
+  entry.size = file_info.size;
+  entry.last_modified_time = file_info.last_modified;
   return entry;
 }
 
 // GDataFileSystemProxy class implementation.
 
 GDataFileSystemProxy::GDataFileSystemProxy(
     GDataFileSystemInterface* file_system)
     : file_system_(file_system) {
   // Should be created from the file browser extension API (AddMountFunction)
   // on UI thread.
@@ skipping 11 matching lines @@
   if (!ValidateUrl(file_url, &file_path)) {
     base::MessageLoopProxy::current()->PostTask(
         FROM_HERE,
         base::Bind(callback,
                    base::PLATFORM_FILE_ERROR_NOT_FOUND,
                    base::PlatformFileInfo(),
                    FilePath()));
     return;
   }
 
-  file_system_->FindEntryByPathAsync(
+  file_system_->GetEntryInfoByPathAsync(
       file_path,
       base::Bind(&GDataFileSystemProxy::OnGetMetadata,
                  this,
                  file_path,
                  callback));
 }
 
 void GDataFileSystemProxy::Copy(const GURL& src_file_url,
     const GURL& dest_file_url,
     const FileSystemOperationInterface::StatusCallback& callback) {
@@ skipping 33 matching lines @@
   if (!ValidateUrl(file_url, &file_path)) {
     base::MessageLoopProxy::current()->PostTask(
         FROM_HERE,
         base::Bind(callback,
                    base::PLATFORM_FILE_ERROR_NOT_FOUND,
                    std::vector<base::FileUtilProxy::Entry>(),
                    false));
     return;
   }
 
-  file_system_->FindEntryByPathAsync(
+  file_system_->ReadDirectoryByPathAsync(
       file_path,
       base::Bind(&GDataFileSystemProxy::OnReadDirectory,
                  this,
                  file_system_->hide_hosted_documents(),
                  callback));
 }
 
 void GDataFileSystemProxy::Remove(const GURL& file_url, bool recursive,
     const FileSystemOperationInterface::StatusCallback& callback) {
   FilePath file_path;
@@ skipping 54 matching lines @@
       type != fileapi::kFileSystemTypeExternal) {
     return false;
   }
   return true;
 }
 
 void GDataFileSystemProxy::OnGetMetadata(
     const FilePath& file_path,
     const FileSystemOperationInterface::GetMetadataCallback& callback,
     base::PlatformFileError error,
-    const FilePath& directory_path,
-    GDataEntry* entry) {
+    scoped_ptr<gdata::GDataEntryProto> entry_proto) {
   if (error != base::PLATFORM_FILE_OK) {
     callback.Run(error, base::PlatformFileInfo(), FilePath());
     return;
   }
+  DCHECK(entry_proto.get());
 
-  callback.Run(base::PLATFORM_FILE_OK, entry->file_info(), file_path);
+  base::PlatformFileInfo file_info;
+  GDataEntry::ConvertProtoToPlatformFileInfo(
+      entry_proto->file_info(),
+      &file_info);
+
+  callback.Run(base::PLATFORM_FILE_OK, file_info, file_path);
 }
 
 void GDataFileSystemProxy::OnReadDirectory(
     bool hide_hosted_documents,
     const FileSystemOperationInterface::ReadDirectoryCallback&
     callback,
     base::PlatformFileError error,
-    const FilePath& directory_path,
-    GDataEntry* entry) {
-  DCHECK(entry || error != base::PLATFORM_FILE_OK);
-
-  GDataDirectory* directory = entry ? entry->AsGDataDirectory() : NULL;
-  if (!directory && error == base::PLATFORM_FILE_OK)
-    error = base::PLATFORM_FILE_ERROR_NOT_A_DIRECTORY;
+    scoped_ptr<gdata::GDataDirectoryProto> directory_proto) {
+  DCHECK(error != base::PLATFORM_FILE_OK);
 
   if (error != base::PLATFORM_FILE_OK) {
     callback.Run(error, std::vector<base::FileUtilProxy::Entry>(), false);
     return;
   }
   std::vector<base::FileUtilProxy::Entry> entries;
   // Convert gdata files to something File API stack can understand.
-  for (GDataDirectoryCollection::const_iterator iter =
-            directory->child_directories().begin();
-       iter != directory->child_directories().end(); ++iter) {
-    entries.push_back(GDataEntryToFileUtilProxyEntry(*(iter->second)));
+  for (int i = 0; i < directory_proto->child_directories_size(); ++i) {
+    const GDataDirectoryProto& proto = directory_proto->child_directories(i);
+    entries.push_back(
+        GDataEntryProtoToFileUtilProxyEntry(proto.gdata_entry()));
   }
-  for (GDataFileCollection::const_iterator iter =
-            directory->child_files().begin();
-       iter != directory->child_files().end(); ++iter) {
-    if (hide_hosted_documents) {
-      GDataFile* file = iter->second;
-      if (file->is_hosted_document())
+  for (int i = 0; i < directory_proto->child_files_size(); ++i) {
+    const GDataFileProto& proto = directory_proto->child_files(i);
+    if (hide_hosted_documents && proto.is_hosted_document())
         continue;
-    }
-    entries.push_back(GDataEntryToFileUtilProxyEntry(*(iter->second)));
+    entries.push_back(
+        GDataEntryProtoToFileUtilProxyEntry(proto.gdata_entry()));
   }
 
   callback.Run(base::PLATFORM_FILE_OK, entries, false);
 }
 
 }  // namespace gdata