GDataFileSystem is no longer a friend of GDataDirectory.

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>
+#include <vector>
 
 #include "base/callback.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/singleton.h"
 #include "base/memory/weak_ptr.h"
 #include "base/platform_file.h"
 #include "base/synchronization/lock.h"
 #include "chrome/browser/chromeos/gdata/gdata_params.h"
 #include "chrome/browser/chromeos/gdata/gdata_uploader.h"
@@ skipping 298 matching lines @@
 
   // Collection of children files/directories.
   const GDataFileCollection& child_files() const { return child_files_; }
   const GDataDirectoryCollection& child_directories() const {
     return child_directories_;
   }
 
  private:
   // TODO(satorux): Remove the friend statements. crbug.com/139649
   friend class GDataDirectoryService;
-  friend class GDataFileSystem;
   friend class GDataWapiFeedProcessor;
 
   explicit GDataDirectory(GDataDirectoryService* directory_service);
 
   // Initializes from DocumentEntry.
   virtual void InitFromDocumentEntry(DocumentEntry* doc) OVERRIDE;
 
   virtual GDataDirectory* AsGDataDirectory() OVERRIDE;
 
   // Adds child file to the directory and takes over the ownership of |file|
@@ skipping 37 matching lines @@
 // TODO(achuith,hashimoto,satorux): Move this to a separate file.
 // crbug.com/140317.
 // Class to handle GDataEntry* lookups, add/remove GDataEntry*.
 class GDataDirectoryService {
  public:
   // Callback for GetEntryByResourceIdAsync.
   typedef base::Callback<void(GDataEntry* entry)> GetEntryByResourceIdCallback;
 
   // Map of resource id and serialized GDataEntry.
   typedef std::map<std::string, std::string> SerializedMap;
+  // Map of resource id strings to GDataEntry*.
+  typedef std::map<std::string, GDataEntry*> ResourceMap;
 
   GDataDirectoryService();
   ~GDataDirectoryService();
 
   GDataDirectory* root() { return root_.get(); }
 
   // Last time when we dumped serialized file system to disk.
   const base::Time& last_serialized() const { return last_serialized_; }
   void set_last_serialized(const base::Time& time) { last_serialized_ = time; }
   // Size of serialized file system on disk in bytes.
@@ skipping 14 matching lines @@
 
   // Creates a GDataFile instance.
   GDataFile* CreateGDataFile();
 
   // Creates a GDataDirectory instance.
   GDataDirectory* CreateGDataDirectory();
 
   // Sets root directory resource id and initialize the root entry.
   void InitializeRootEntry(const std::string& root_id);
 
+  // Add |new entry| to |directory| and invoke the callback asynchronously.
+  // |callback| may not be null.
+  // TODO(achuith,satorux): Use GDataEntryProto instead for new_entry.
+  // crbug.com/142048
+  void AddEntryToDirectory(GDataDirectory* directory,
+                           GDataEntry* new_entry,
+                           const FileMoveCallback& callback);
+
   // Move |entry| to |directory_path| asynchronously. Removes entry from
   // previous parent. Must be called on UI thread. |callback| is called on the
-  // UI thread.
+  // UI thread. |callback| may be null.
   void MoveEntryToDirectory(const FilePath& directory_path,
                             GDataEntry* entry,
                             const FileMoveCallback& callback);
 
+  // Remove |entry| from its parent. Calls |callback| with the path of the
+  // parent directory. |callback| can be null.
+  void RemoveEntryFromParent(GDataEntry* entry,
+                             const FileMoveCallback& callback);
+
   // Adds the entry to resource map.
   void AddEntryToResourceMap(GDataEntry* entry);
 
   // Removes the entry from resource map.
   void RemoveEntryFromResourceMap(GDataEntry* entry);
 
   // Searches for |file_path| synchronously.
   // TODO(satorux): Replace this with an async version crbug.com/137160
   GDataEntry* FindEntryByPathSync(const FilePath& file_path);
 
@@ skipping 31 matching lines @@
   // 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);
+  // Remove all child files of |directory| and replace with file_map.
+  // Note that |callback| is only called if the directory is successfully

[satorux1, 2012/08/11 11:48:17]

this behavior looks unusual. In other places, we call a callback with an error
code when an operation failed. I think it'd be nicer to do the same here too.

[achuithb, 2012/08/13 22:18:10]

Good point. Done.

+  // refreshed. |callback| is called with the directory path.
+  // |callback| may not be null.
+  void RefreshDirectory(const std::string& directory_resource_id,
+                        const ResourceMap& file_map,
+                        const FileMoveCallback& callback);
 
   // Serializes/Parses to/from string via proto classes.
   void SerializeToString(std::string* serialized_proto) const;
   bool ParseFromString(const std::string& serialized_proto);
 
   // Restores from and saves to database.
   void InitFromDB(const FilePath& db_path,
                   base::SequencedTaskRunner* blocking_task_runner,
                   const FileOperationCallback& callback);
   void SaveToDB();
 
  private:
-  // A map table of file's resource string to its GDataFile* entry.
-  typedef std::map<std::string, GDataEntry*> ResourceMap;
-
   // Initializes the resource map using serialized_resources fetched from the
   // database.
   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);
 
-  // ...
+  // Continue with GetEntryInfoPairByPaths after the first GDataEntry has been
+  // asynchronously fetched. This fetches the second GDataEntry only if the
+  // first was found.

[satorux1, 2012/08/11 11:48:17]

Thanks!

[achuithb, 2012/08/13 22:18:10]

Np.

   void GetEntryInfoPairByPathsAfterGetFirst(
       const FilePath& first_path,
       const FilePath& second_path,
       const GetEntryInfoPairCallback& callback,
       GDataFileError error,
       scoped_ptr<GDataEntryProto> entry_proto);
 
-  // ...
+  // Continue with GetIntroInfoPairByPaths after the second GDataEntry has been
+  // asynchronously fetched.
   void GetEntryInfoPairByPathsAfterGetSecond(
       const FilePath& second_path,
       const GetEntryInfoPairCallback& callback,
       scoped_ptr<EntryInfoPairResult> result,
       GDataFileError error,
       scoped_ptr<GDataEntryProto> entry_proto);
 
+  // These internal functions need friend access to private GDataDirectory
+  // methods.
+  // Replaces file entry |old_entry| with its fresh value |fresh_file|.
+  static void RefreshFileInternal(scoped_ptr<GDataFile> fresh_file,
+                                  GDataEntry* old_entry);
+
+  // Remove all child files of |directory| and replace with file_map.

[satorux1, 2012/08/11 11:48:17]

Removes

+  // Note that |callback| is only called if the directory is successfully
+  // refreshed. |callback| may not be null.

[satorux1, 2012/08/11 11:48:17]

Ditto. This behavior is worrisome.

[achuithb, 2012/08/13 22:18:10]

Done.

+  static void RefreshDirectoryInternal(const ResourceMap& file_map,
+                                       const FileMoveCallback& callback,
+                                       GDataEntry* directory_entry);
+
+
   // 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_;
   int64 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_