gdata: Add GDataDirectoryService::GetEntryInfoPairByPaths()

chrome/browser/chromeos/gdata/gdata_files.h

 // 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.
 
 #ifndef CHROME_BROWSER_CHROMEOS_GDATA_GDATA_FILES_H_
 #define CHROME_BROWSER_CHROMEOS_GDATA_GDATA_FILES_H_
 
 #include <map>
 #include <string>
 
@@ skipping 70 matching lines @@
     GetEntryInfoCallback;
 
 // Used to read a directory from the file system.
 // If |error| is not GDATA_FILE_OK, |entries| is set to NULL.
 // |entries| are contents, both files and directories, of the directory.
 typedef std::vector<GDataEntryProto> GDataEntryProtoVector;
 typedef base::Callback<void(GDataFileError error,
                             scoped_ptr<GDataEntryProtoVector> entries)>
     ReadDirectoryCallback;
 
+// The result of GetEntryInfoPairCallback(). Used to get a pair of entries
+// in one function call.
+struct EntryInfoPairResult {
+  EntryInfoPairResult();
+  ~EntryInfoPairResult();
+
+  FilePath first_path;

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

Have you considered creating another struct like
struct EntryInfoResult {
  EntryInfoResult(const FilePath& path, GDataFileError error,
scoped_ptr<GDataEntryProto> proto);
  FilePath path; 
  GDataFileError error;
  scoped_ptr<GDataEntryProto> proto;
}

and then
struct EntryInfoPairResult {
  EntryInfoResult first;
  EntryInfoResult second;
};

I think this will make the code cleaner (especially having the ctor for
EntryInfoResult).

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

Considered but I was too lazy to rewrite. :) Reconsidered and changed per your
suggestion.

+  GDataFileError first_error;
+  scoped_ptr<GDataEntryProto> first_proto;
+
+  // The following fields are filled only if the first path is found.
+  FilePath second_path;
+  GDataFileError second_error;
+  scoped_ptr<GDataEntryProto> second_proto;
+};
+
+// Used to receive the result from GetEntryInfoPairCallback().
+typedef base::Callback<void(scoped_ptr<EntryInfoPairResult> pair_result)>
+    GetEntryInfoPairCallback;
+
 // Base class for representing files and directories in gdata virtual file
 // system.
 class GDataEntry {
  public:
   GDataEntry(GDataDirectory* parent, GDataDirectoryService* directory_service);
   virtual ~GDataEntry();
 
   virtual GDataFile* AsGDataFile();
   virtual GDataDirectory* AsGDataDirectory();
 
@@ skipping 321 matching lines @@
   // Must be called from UI thread. |callback| is run on UI thread.
   void GetEntryInfoByPath(const FilePath& file_path,
                           const GetEntryInfoCallback& callback);
 
   // Finds and reads a directory by |file_path|.
   //
   // Must be called from UI thread. |callback| is run on UI thread.
   void ReadDirectoryByPath(const FilePath& file_path,
                            const ReadDirectoryCallback& callback);
 
+  // Similar to GetEntryInfoByPath() but this function finds a pair of
+  // entries by |first_path| and |second_path|. If the entry for
+  // |first_path| is not found, this function does not try to get the
+  // entry of |second_path|.
+  //
+  // Must be called from UI thread. |callback| is run on UI thread.
+  void GetEntryInfoPairByPaths(
+      const FilePath& first_path,
+      const FilePath& second_path,
+      const GetEntryInfoPairCallback& callback);
+
   // Replaces file entry with the same resource id as |fresh_file| with its
   // fresh value |fresh_file|.
   void RefreshFile(scoped_ptr<GDataFile> fresh_file);
 
   // Replaces file entry |old_entry| with its fresh value |fresh_file|.
   static void RefreshFileInternal(scoped_ptr<GDataFile> fresh_file,
                                   GDataEntry* old_entry);
 
   // Serializes/Parses to/from string via proto classes.
   void SerializeToString(std::string* serialized_proto) const;
@@ skipping 14 matching lines @@
   void InitResourceMap(CreateDBParams* create_params,
                        const FileOperationCallback& callback);
 
   // Clears root_ and the resource map.
   void ClearRoot();
 
   // Creates GDataEntry from serialized string.
   scoped_ptr<GDataEntry> FromProtoString(
       const std::string& serialized_proto);
 
+  // ...
+  void GetEntryInfoPairByPathsAfterGetFirst(
+      const FilePath& first_path,
+      const FilePath& second_path,
+      const GetEntryInfoPairCallback& callback,
+      GDataFileError error,
+      scoped_ptr<GDataEntryProto> entry_proto);
+
+  // ...
+  void GetEntryInfoPairByPathsAfterGetSecond(
+      const FilePath& second_path,
+      const GetEntryInfoPairCallback& callback,
+      scoped_ptr<EntryInfoPairResult> result,
+      GDataFileError error,
+      scoped_ptr<GDataEntryProto> entry_proto);
+
   // Private data members.
   scoped_refptr<base::SequencedTaskRunner> blocking_task_runner_;
   scoped_ptr<ResourceMetadataDB> directory_service_db_;
 
   ResourceMap resource_map_;
 
   scoped_ptr<GDataDirectory> root_;  // Stored in the serialized proto.
 
   base::Time last_serialized_;
   size_t serialized_size_;
   int largest_changestamp_;  // Stored in the serialized proto.
   ContentOrigin origin_;
 
   // This should remain the last member so it'll be destroyed first and
   // invalidate its weak pointers before other members are destroyed.
   base::WeakPtrFactory<GDataDirectoryService> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(GDataDirectoryService);
 };
 
 }  // namespace gdata
 
 #endif  // CHROME_BROWSER_CHROMEOS_GDATA_GDATA_FILES_H_