Parent/child fixes.

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_
 #pragma once
 
 #include <map>
 #include <string>
@@ skipping 53 matching lines @@
   virtual GDataFile* AsGDataFile();
   virtual GDataDirectory* AsGDataDirectory();
   virtual GDataRootDirectory* AsGDataRootDirectory();
 
   // const versions of AsGDataFile and AsGDataDirectory.
   const GDataFile* AsGDataFileConst() const;
   const GDataDirectory* AsGDataDirectoryConst() const;
 
   // Converts DocumentEntry into GDataEntry.
   static GDataEntry* FromDocumentEntry(GDataDirectory* parent,
-                                          DocumentEntry* doc,
-                                          GDataRootDirectory* root);
+                                       DocumentEntry* doc,
+                                       GDataRootDirectory* root);
 
   // Serialize/Parse to/from string via proto classes.
   // TODO(achuith): Correctly set up parent_ and root_ links in
   // FromProtoString.
   void SerializeToString(std::string* serialized_proto) const;
   static scoped_ptr<GDataEntry> FromProtoString(
       const std::string& serialized_proto);
 
   // Converts to/from proto.
   void FromProto(const GDataEntryProto& proto);
   void ToProto(GDataEntryProto* proto) const;
 
   // Escapes forward slashes from file names with magic unicode character
   // \u2215 pretty much looks the same in UI.
   static std::string EscapeUtf8FileName(const std::string& input);
 
   // Unescapes what was escaped in EScapeUtf8FileName.
   static std::string UnescapeUtf8FileName(const std::string& input);
 
-  GDataDirectory* parent() { return parent_; }
+  // Return the parent of this entry. NULL for root.
+  GDataDirectory* parent() const { return parent_; }
   const base::PlatformFileInfo& file_info() const { return file_info_; }
 
   const FilePath::StringType& file_name() const { return file_name_; }
+  // Sets the file name. file_name_ gets reset by SetFileNameFromTitle().
   void set_file_name(const FilePath::StringType& name) { file_name_ = name; }

[satorux1, 2012/04/27 21:35:41]

Could you also emphasize that this does not contain the directory path, and you
should use GetFilePath() for that? That said, it may make sense to rename it to
"base name".

Besides, you might want to make it private or protected.

[achuithb, 2012/04/27 22:15:03]

I have added the comment.

I use it in gdata_db_unittest. I'll add a TODO here to make this private when I
get rid of paths in GDataDB.

base_name is a good idea.

I'll rename in the next CL so the diff stays manageable, unless you want me to
do it here.

[satorux1, 2012/04/27 22:29:41]

Please do it in a separate patch! :)

 
   const FilePath::StringType& title() const { return title_; }
   void set_title(const FilePath::StringType& title) { title_ = title; }
 
   // The unique resource ID associated with this file system entry.
   const std::string& resource_id() const { return resource_id_; }
   void set_resource_id(const std::string& res_id) { resource_id_ = res_id; }
 
   // The content URL is used for downloading regular files as is.
   const GURL& content_url() const { return content_url_; }
@@ skipping 14 matching lines @@
   // Returns virtual file path representing this file system entry. This path
   // corresponds to file path expected by public methods of GDataFileSyste
   // class.
   FilePath GetFilePath() const;
 
   // Sets |file_name_| based on the value of |title_| without name
   // de-duplication (see AddEntry() for details on de-duplication).
   virtual void SetFileNameFromTitle();
 
  protected:
-  // GDataDirectory::TakeEntry() needs to call GDataEntry::set_parent().
+  // For access to SetParent from AddEntry.
   friend class GDataDirectory;
 
   // Sets the parent directory of this file system entry.
   // It is intended to be used by GDataDirectory::AddEntry() only.
-  void set_parent(GDataDirectory* parent) { parent_ = parent; }
+  void SetParent(GDataDirectory* parent);
 
   base::PlatformFileInfo file_info_;
-  // Name of this file in the gdata virtual file system.
-  FilePath::StringType file_name_;
   // Title of this file (i.e. the 'title' attribute associated with a regular
   // file, hosted document, or collection). The title is used to derive
   // |file_name_| but may be different from |file_name_|. For example,
   // |file_name_| has an added .g<something> extension for hosted documents or
   // may have an extra suffix for name de-duplication on the gdata file system.
   FilePath::StringType title_;
   std::string resource_id_;
+  std::string parent_resource_id_;
   // Files with the same title will be uniquely identified with this field
   // so we can represent them with unique URLs/paths in File API layer.
   // For example, two files in the same directory with the same name "Foo"
   // will show up in the virtual directory as "Foo" and "Foo (2)".
   GURL edit_url_;
   GURL content_url_;
+
+  // Remaining fields are not serialized.
+
+  // Name of this file in the gdata virtual file system. This can change
+  // due to de-duplication (See AddEntry).
+  FilePath::StringType file_name_;
+
   GDataDirectory* parent_;
   GDataRootDirectory* root_;  // Weak pointer to GDataRootDirectory.
   bool deleted_;
-  std::string parent_resource_id_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(GDataEntry);
 };
 
-typedef std::map<FilePath::StringType, GDataEntry*> GDataFileCollection;
+typedef std::map<FilePath::StringType, GDataFile*> GDataFileCollection;
+typedef std::map<FilePath::StringType, GDataDirectory*>
+    GDataDirectoryCollection;
 
 // Represents "file" in in a GData virtual file system. On gdata feed side,
 // this could be either a regular file or a server side document.
 class GDataFile : public GDataEntry {
  public:
   // This is used as a bitmask for the cache state.
   enum CacheState {
     CACHE_STATE_NONE    = 0x0,
     CACHE_STATE_PINNED  = 0x1 << 0,
     CACHE_STATE_PRESENT = 0x1 << 1,
     CACHE_STATE_DIRTY   = 0x1 << 2,
     CACHE_STATE_MOUNTED = 0x1 << 3,
   };
 
   explicit GDataFile(GDataDirectory* parent, GDataRootDirectory* root);
   virtual ~GDataFile();
   virtual GDataFile* AsGDataFile() OVERRIDE;
 
+  // Converts DocumentEntry into GDataEntry.
   static GDataEntry* FromDocumentEntry(GDataDirectory* parent,
-                                          DocumentEntry* doc,
-                                          GDataRootDirectory* root);
+                                       DocumentEntry* doc,
+                                       GDataRootDirectory* root);
 
   // Converts to/from proto.
   void FromProto(const GDataFileProto& proto);
   void ToProto(GDataFileProto* proto) const;
 
   static bool IsCachePresent(int cache_state) {
     return cache_state & CACHE_STATE_PRESENT;
   }
   static bool IsCachePinned(int cache_state) {
     return cache_state & CACHE_STATE_PINNED;
@@ skipping 61 matching lines @@
 };
 
 // Represents "directory" in a GData virtual file system. Maps to gdata
 // collection element.
 class GDataDirectory : public GDataEntry {
  public:
   GDataDirectory(GDataDirectory* parent, GDataRootDirectory* root);
   virtual ~GDataDirectory();
   virtual GDataDirectory* AsGDataDirectory() OVERRIDE;
 
+  // Converts DocumentEntry into GDataEntry.
   static GDataEntry* FromDocumentEntry(GDataDirectory* parent,
-                                          DocumentEntry* doc,
-                                          GDataRootDirectory* root);
+                                       DocumentEntry* doc,
+                                       GDataRootDirectory* root);
 
   // Converts to/from proto.
   void FromProto(const GDataDirectoryProto& proto);
   void ToProto(GDataDirectoryProto* proto) const;
 
   // Adds child file to the directory and takes over the ownership of |file|
   // object. The method will also do name de-duplication to ensure that the
   // exposed presentation path does not have naming conflicts. Two files with
   // the same name "Foo" will be renames to "Foo (1)" and "Foo (2)".
   void AddEntry(GDataEntry* entry);
 
   // Takes the ownership of |entry| from its current parent. If this directory
   // is already the current parent of |file|, this method effectively goes
   // through the name de-duplication for |file| based on the current state of
   // the file system.
   bool TakeEntry(GDataEntry* entry);
 
   // Takes over all entries from |dir|.
   bool TakeOverEntries(GDataDirectory* dir);
 
+  // Find a child by its name.
+  GDataEntry* FindChild(const FilePath::StringType& file_name) const;
+
   // Removes the entry from its children list and destroys the entry instance.
   bool RemoveEntry(GDataEntry* entry);
 
   // Removes children elements.
   void RemoveChildren();
 
   // Checks if directory content needs to be refreshed from the server.
   bool NeedsRefresh() const;
 
   // Last refresh time.
   const base::Time& refresh_time() const { return refresh_time_; }
   void set_refresh_time(const base::Time& time) { refresh_time_ = time; }
   // Url for this feed.
   const GURL& start_feed_url() const { return start_feed_url_; }
   void set_start_feed_url(const GURL& url) { start_feed_url_ = url; }
   // Continuing feed's url.
   const GURL& next_feed_url() const { return next_feed_url_; }
   void set_next_feed_url(const GURL& url) { next_feed_url_ = url; }
   // Upload url is an entry point for initialization of file upload.
   // It corresponds to resumable-create-media link from gdata feed.
   const GURL& upload_url() const { return upload_url_; }
   void set_upload_url(const GURL& url) { upload_url_ = url; }
-  // Collection of children GDataEntry items.
-  const GDataFileCollection& children() const { return children_; }
+  // Collection of children files/directories.
+  const GDataFileCollection& child_files() const { return child_files_; }
+  const GDataDirectoryCollection& child_directories() const {
+    return child_directories_;
+  }
   // Directory content origin.
   const ContentOrigin origin() const { return origin_; }
   void set_origin(ContentOrigin value) { origin_ = value; }
 
  private:
-  // Removes the entry from its children list without destroying the
+  // Add |entry| to children.
+  void AddChild(GDataEntry* entry);
+
+  // Removes the entry from its children without destroying the
   // entry instance.
-  bool RemoveEntryFromChildrenList(GDataEntry* entry);
+  bool RemoveChild(GDataEntry* entry);
 
   base::Time refresh_time_;
   // Url for this feed.
   GURL start_feed_url_;
   // Continuing feed's url.
   GURL next_feed_url_;
   // Upload url, corresponds to resumable-create-media link for feed
   // representing this directory.
   GURL upload_url_;
 
   // Directory content origin.
   ContentOrigin origin_;
 
   // Collection of children GDataEntry items.
-  GDataFileCollection children_;
+  GDataFileCollection child_files_;
+  GDataDirectoryCollection child_directories_;
 
   DISALLOW_COPY_AND_ASSIGN(GDataDirectory);
 };
 
 class GDataRootDirectory : public GDataDirectory {
  public:
   // Enum defining GCache subdirectory location.
   // This indexes into |GDataFileSystem::cache_paths_| vector.
   enum CacheSubDirectoryType {
     CACHE_TYPE_META = 0,       // Downloaded feeds.
@@ skipping 64 matching lines @@
 
   // GDataEntry implementation.
   virtual GDataRootDirectory* AsGDataRootDirectory() OVERRIDE;
 
   // Adds the entry to resource map.
   void AddEntryToResourceMap(GDataEntry* entry);
 
   // Removes the entry from resource map.
   void RemoveEntryFromResourceMap(GDataEntry* entry);
 
-  // Removes the entries from resource map.
-  void RemoveEntriesFromResourceMap(const GDataFileCollection& children);
-
   // Searches for |file_path| triggering callback in |delegate|.
   void FindEntryByPath(const FilePath& file_path,
                        FindEntryDelegate* delegate);
 
   // Returns the GDataEntry* with the corresponding |resource_id|.
   GDataEntry* GetEntryByResourceId(const std::string& resource_id);
 
   // Sets |cache_map_| data member to formal parameter |new_cache_map|.
   void SetCacheMap(const CacheMap& new_cache_map);
 
@@ skipping 33 matching lines @@
   base::Time last_serialized_;
   int largest_changestamp_;
   size_t serialized_size_;
 
   DISALLOW_COPY_AND_ASSIGN(GDataRootDirectory);
 };
 
 }  // namespace gdata
 
 #endif  // CHROME_BROWSER_CHROMEOS_GDATA_GDATA_FILES_H_