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_; }
 
+  // This is not the full path, use GetFilePath for that.
+  // Note that file_name_ gets reset by SetFileNameFromTitle() in a number of
+  // situations due to de-duplication (see AddEntry).
+  // TODO(achuith/satorux): Rename this to base_name.
   const FilePath::StringType& file_name() const { return file_name_; }
+  // TODO(achuith): Make this private when GDataDB no longer uses path as a key.
   void set_file_name(const FilePath::StringType& name) { file_name_ = name; }
 
   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.
@@ skipping 15 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_; }

[zel, 2012/04/27 23:10:31]

it would be great to provide an iterator that goes over both

[achuithb, 2012/04/28 00:20:15]

Yup, we would hide the read from the database (as necessary) behind such an
iterator.

+  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_