gdata: Add GDataFileSystem::GetEntryByPathAsync()

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 791 matching lines @@
 // Ditto for SetMountedStateCallback.
 void RelaySetMountedStateCallback(
     scoped_refptr<base::MessageLoopProxy> relay_proxy,
     const SetMountedStateCallback& callback,
     base::PlatformFileError error,
     const FilePath& file_path) {
   relay_proxy->PostTask(FROM_HERE,
                         base::Bind(callback, error, file_path));
 }
 
+// Ditto for GetEntryInfoCallback.
+void RelayGetEntryInfoCallback(
+    scoped_refptr<base::MessageLoopProxy> relay_proxy,
+    const GetEntryInfoCallback& callback,
+    base::PlatformFileError error,
+    scoped_ptr<GDataEntryProto> entry_proto) {
+  relay_proxy->PostTask(
+      FROM_HERE,
+      base::Bind(callback, error, base::Passed(&entry_proto)));
+}
+
 // Ditto for GetFileInfoCallback.
 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)));
 }
@@ skipping 1298 matching lines @@
 }
 
 void GDataFileSystem::ResumeUpload(
     const ResumeUploadParams& params,
     const ResumeFileUploadCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   documents_service_->ResumeUpload(params, callback);
 }
 
+void GDataFileSystem::GetEntryInfoByPathAsync(

[achuithb, 2012/05/01 09:27:09]

This is a lot of boiler plate copy and paste. Is there a way to templatize this?
We're adding quite a bit of code to this already large file, and so much of it
is repetitive.

[satorux1, 2012/05/01 16:50:41]

I totally agree with you that the code is overly repetitive. I originally tried
to consolidate boiler plate but I wasn't able to come up with a good way to do
it.

One idea is to hide GDataFileSystem class into the .cc file (which you suggested
before IIRC) so we can templatize functions aggressively, without worrying about
putting lots of code in .h file, but this will be a large change, so I'd do it
at a later time. I'll file a cleanup bug on this.

+    const FilePath& file_path,
+    const GetEntryInfoCallback& callback) {
+  if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+    const bool posted = BrowserThread::PostTask(
+        BrowserThread::UI,
+        FROM_HERE,
+        base::Bind(&GDataFileSystem::GetEntryInfoByPathAsyncOnUIThread,
+                   ui_weak_ptr_,
+                   file_path,
+                   base::Bind(&RelayGetEntryInfoCallback,
+                              base::MessageLoopProxy::current(),
+                              callback)));
+    DCHECK(posted);
+    return;
+  }
+
+  GetEntryInfoByPathAsyncOnUIThread(file_path, callback);
+}
+
+void GDataFileSystem::GetEntryInfoByPathAsyncOnUIThread(
+    const FilePath& file_path,
+    const GetEntryInfoCallback& callback) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  FindEntryByPathAsyncOnUIThread(
+      file_path,
+      base::Bind(&GDataFileSystem::OnGetEntryInfo,
+                 ui_weak_ptr_,
+                 callback));
+}
+
+void GDataFileSystem::OnGetEntryInfo(const GetEntryInfoCallback& 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<GDataEntryProto>());
+    return;
+  }
+  DCHECK(entry);
+
+  scoped_ptr<GDataEntryProto> entry_proto(new GDataEntryProto);
+  entry->ToProto(entry_proto.get());
+
+  if (!callback.is_null())
+    callback.Run(base::PLATFORM_FILE_OK, entry_proto.Pass());
+}
+
 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::GetFileInfoByPathAsyncOnUIThread,
                    ui_weak_ptr_,
@@ skipping 24 matching lines @@
                                     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;
   }
+  DCHECK(entry);
 
   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);
@@ skipping 40 matching lines @@
                                       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;
   }
+  DCHECK(entry);
 
   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);
@@ skipping 2471 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