gdata: Add GDataFileSystem::ReadDirectoryByPathAsync()

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 <errno.h>
 #include <sys/stat.h>
 
 #include <set>
@@ skipping 802 matching lines @@
 void RelayGetFileInfoCallback(
     scoped_refptr<base::MessageLoopProxy> relay_proxy,
     const GetFileInfoCallback& callback,
     base::PlatformFileError error,
     scoped_ptr<GDataFileProto> file_proto) {
   relay_proxy->PostTask(
       FROM_HERE,
       base::Bind(callback, error, base::Passed(&file_proto)));
 }
 
+// Ditto for ReadDirectoryCallback.
+void RelayReadDirectoryCallback(
+    scoped_refptr<base::MessageLoopProxy> relay_proxy,
+    const ReadDirectoryCallback& callback,
+    base::PlatformFileError error,
+    scoped_ptr<GDataDirectoryProto> directory_proto) {
+  relay_proxy->PostTask(
+      FROM_HERE,
+      base::Bind(callback, error, base::Passed(&directory_proto)));
+}
+
 }  // namespace
 
 // GDataFileProperties struct implementation.
 
 GDataFileProperties::GDataFileProperties() : is_hosted_document(false) {
 }
 
 GDataFileProperties::~GDataFileProperties() {
 }
 
@@ skipping 1284 matching lines @@
 }
 
 void GDataFileSystem::GetFileInfoByPathAsync(
     const FilePath& file_path,
     const GetFileInfoCallback& callback) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
     const bool posted = BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
-        base::Bind(&GDataFileSystem::GetFileInfoByPathAsync,
+        base::Bind(&GDataFileSystem::GetFileInfoByPathAsyncOnUIThread,
                    ui_weak_ptr_,
                    file_path,
                    base::Bind(&RelayGetFileInfoCallback,
                               base::MessageLoopProxy::current(),
                               callback)));
     DCHECK(posted);
     return;
   }
 
   GetFileInfoByPathAsyncOnUIThread(file_path, callback);
 }
 
 void GDataFileSystem::GetFileInfoByPathAsyncOnUIThread(
     const FilePath& file_path,
     const GetFileInfoCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   FindEntryByPathAsyncOnUIThread(
       file_path,
-      base::Bind(&GDataFileSystem::OnEntryFound,
+      base::Bind(&GDataFileSystem::OnGetFileInfo,
                  ui_weak_ptr_,
                  callback));
 }
 
-void GDataFileSystem::OnEntryFound(const GetFileInfoCallback& callback,
-                                   base::PlatformFileError error,
-                                   const FilePath& directory_path,
-                                   GDataEntry* entry) {
+void GDataFileSystem::OnGetFileInfo(const GetFileInfoCallback& callback,
+                                    base::PlatformFileError error,
+                                    const FilePath& directory_path,
+                                    GDataEntry* entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (error != base::PLATFORM_FILE_OK) {
     if (!callback.is_null())
       callback.Run(error, scoped_ptr<GDataFileProto>());
     return;
   }
 
   GDataFile* file = entry->AsGDataFile();
   if (!file) {
     if (!callback.is_null())
       callback.Run(base::PLATFORM_FILE_ERROR_NOT_FOUND,
                    scoped_ptr<GDataFileProto>());
     return;
   }
 
   scoped_ptr<GDataFileProto> file_proto(new GDataFileProto);
   file->ToProto(file_proto.get());
 
   if (!callback.is_null())
     callback.Run(base::PLATFORM_FILE_OK, file_proto.Pass());
 }
 
+void GDataFileSystem::ReadDirectoryByPathAsync(
+    const FilePath& file_path,
+    const ReadDirectoryCallback& callback) {
+  if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+    const bool posted = BrowserThread::PostTask(
+        BrowserThread::UI,
+        FROM_HERE,
+        base::Bind(&GDataFileSystem::ReadDirectoryByPathAsyncOnUIThread,
+                   ui_weak_ptr_,
+                   file_path,
+                   base::Bind(&RelayReadDirectoryCallback,
+                              base::MessageLoopProxy::current(),
+                              callback)));
+    DCHECK(posted);
+    return;
+  }
+
+  ReadDirectoryByPathAsyncOnUIThread(file_path, callback);
+}
+
+void GDataFileSystem::ReadDirectoryByPathAsyncOnUIThread(
+    const FilePath& file_path,
+    const ReadDirectoryCallback& callback) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  FindEntryByPathAsyncOnUIThread(
+      file_path,
+      base::Bind(&GDataFileSystem::OnReadDirectory,
+                 ui_weak_ptr_,
+                 callback));
+}
+
+void GDataFileSystem::OnReadDirectory(const ReadDirectoryCallback& callback,
+                                      base::PlatformFileError error,
+                                      const FilePath& directory_path,
+                                      GDataEntry* entry) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  if (error != base::PLATFORM_FILE_OK) {
+    if (!callback.is_null())
+      callback.Run(error, scoped_ptr<GDataDirectoryProto>());
+    return;
+  }
+
+  GDataDirectory* directory = entry->AsGDataDirectory();
+  if (!directory) {
+    if (!callback.is_null())
+      callback.Run(base::PLATFORM_FILE_ERROR_NOT_FOUND,
+                   scoped_ptr<GDataDirectoryProto>());
+    return;
+  }
+
+  scoped_ptr<GDataDirectoryProto> directory_proto(new GDataDirectoryProto);
+  directory->ToProto(directory_proto.get());
+
+  if (!callback.is_null())
+    callback.Run(base::PLATFORM_FILE_OK, directory_proto.Pass());
+}
+
 bool GDataFileSystem::GetFileInfoByPath(
     const FilePath& file_path, GDataFileProperties* properties) {
   DCHECK(properties);
   base::AutoLock lock(lock_);
   GDataEntry* entry = GetGDataEntryByPath(file_path);
   if (!entry)
     return false;
 
   properties->file_info = entry->file_info();
   properties->resource_id = entry->resource_id();
@@ skipping 2455 matching lines @@
   pref_registrar_->Init(profile_->GetPrefs());
   pref_registrar_->Add(prefs::kDisableGDataHostedFiles, this);
 }
 
 void SetFreeDiskSpaceGetterForTesting(FreeDiskSpaceGetterInterface* getter) {
   delete global_free_disk_getter_for_testing;  // Safe to delete NULL;
   global_free_disk_getter_for_testing = getter;
 }
 
 }  // namespace gdata