gdata: Add GDataDirectoryService::GetEntryInfoPairByPaths()

chrome/browser/chromeos/gdata/gdata_files.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_files.h"
 
 #include <leveldb/db.h>
 #include <vector>
 
 #include "base/message_loop_proxy.h"
@@ skipping 48 matching lines @@
     LOG(ERROR) << "Incompatible proto detected (bad resource ID): "
                << entry_proto.resource_id();
     return false;
   }
 
   return true;
 }
 
 }  // namespace
 
+EntryInfoPairResult::EntryInfoPairResult()
+    : first_error(GDATA_FILE_ERROR_FAILED),
+      second_error(GDATA_FILE_ERROR_FAILED) {
+}
+
+EntryInfoPairResult::~EntryInfoPairResult() {
+}
+
 // GDataEntry class.
 
 GDataEntry::GDataEntry(GDataDirectory* parent,
                        GDataDirectoryService* directory_service)
     : directory_service_(directory_service),
       deleted_(false) {
   SetParent(parent);
 }
 
 GDataEntry::~GDataEntry() {
@@ skipping 612 matching lines @@
     error = GDATA_FILE_ERROR_NOT_A_DIRECTORY;
   } else {
     error = GDATA_FILE_ERROR_NOT_FOUND;
   }
 
   base::MessageLoopProxy::current()->PostTask(
       FROM_HERE,
       base::Bind(callback, error, base::Passed(&entries)));
 }
 
+void GDataDirectoryService::GetEntryInfoPairByPaths(
+    const FilePath& first_path,
+    const FilePath& second_path,
+    const GetEntryInfoPairCallback& callback) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(!callback.is_null());
+
+  // Get the first entry.
+  GetEntryInfoByPath(
+      first_path,
+      base::Bind(&GDataDirectoryService::GetEntryInfoPairByPathsAfterGetFirst,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 first_path,
+                 second_path,
+                 callback));
+}
+
 void GDataDirectoryService::RefreshFile(scoped_ptr<GDataFile> fresh_file) {
   DCHECK(fresh_file.get());
 
   // Need to get a reference here because Passed() could get evaluated first.
   const std::string& resource_id = fresh_file->resource_id();
   GetEntryByResourceIdAsync(
       resource_id,
       base::Bind(&GDataDirectoryService::RefreshFileInternal,
                  base::Passed(&fresh_file)));
 }
@@ skipping 426 matching lines @@
     // Call GDataFile::FromProto.
     if (file->FromProto(entry_proto)) {
       entry.reset(file.release());
     } else {
       NOTREACHED() << "FromProto (file) failed";
     }
   }
   return entry.Pass();
 }
 
+void GDataDirectoryService::GetEntryInfoPairByPathsAfterGetFirst(
+    const FilePath& first_path,
+    const FilePath& second_path,
+    const GetEntryInfoPairCallback& callback,
+    GDataFileError error,
+    scoped_ptr<GDataEntryProto> entry_proto) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(!callback.is_null());
+
+  scoped_ptr<EntryInfoPairResult> result(new EntryInfoPairResult);
+  result->first_path = first_path;
+  result->first_error = error;
+  result->first_proto = entry_proto.Pass();
+
+  if (error != GDATA_FILE_OK) {
+    callback.Run(result.Pass());
+    return;

[achuithb, 2012/08/08 20:50:32]

Why is this necessary? Why not look for the second one?

[satorux1, 2012/08/08 21:21:21]

Looking at the code in gdata_file_system.cc, we don't need to look for the
second one if the first one is not found. We can revisit this at a later time,
if there is an exception.

+  }
+
+  // Get the second entry.
+  GetEntryInfoByPath(
+      second_path,
+      base::Bind(&GDataDirectoryService::GetEntryInfoPairByPathsAfterGetSecond,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 second_path,
+                 callback,
+                 base::Passed(&result)));
+}
+
+void GDataDirectoryService::GetEntryInfoPairByPathsAfterGetSecond(
+    const FilePath& second_path,
+    const GetEntryInfoPairCallback& callback,
+    scoped_ptr<EntryInfoPairResult> result,
+    GDataFileError error,
+    scoped_ptr<GDataEntryProto> entry_proto) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(!callback.is_null());
+  DCHECK(result.get());
+
+  result->second_path = second_path;
+  result->second_error = error;
+  result->second_proto = entry_proto.Pass();
+
+  callback.Run(result.Pass());
+}
+
 }  // namespace gdata