Extend and refactor GDataFileBase and derived classes.

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 <sys/stat.h>
+
 #include <map>
-#include <sys/stat.h>
+#include <string>
 
 #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.h"
 #include "chrome/browser/chromeos/gdata/gdata_parser.h"
 #include "chrome/browser/chromeos/gdata/gdata_uploader.h"
@@ skipping 12 matching lines @@
  public:
   explicit GDataFileBase(GDataDirectory* parent);
   virtual ~GDataFileBase();
   virtual GDataFile* AsGDataFile();
   virtual GDataDirectory* AsGDataDirectory();
   virtual GDataRootDirectory* AsGDataRootDirectory();
 
   // Converts DocumentEntry into GDataFileBase.
   static GDataFileBase* FromDocumentEntry(GDataDirectory* parent,
                                           DocumentEntry* doc);
+
+  // 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_; }
   const base::PlatformFileInfo& file_info() const { return file_info_; }
   const FilePath::StringType& file_name() const { return file_name_; }
   const FilePath::StringType& original_file_name() const {
     return original_file_name_;
   }
+  void set_original_file_name(const FilePath::StringType& name) {
+    original_file_name_ = name;
+  }
   void set_file_name(const FilePath::StringType& name) { file_name_ = name; }
 
+  // The unique resource ID associated with this file system entry.
+  const std::string& resource_id() const { return resource_id_; }
+
   // The content URL is used for downloading regular files as is.
   const GURL& content_url() const { return content_url_; }
 
   // The self URL is used for removing files and hosted documents.
   const GURL& self_url() const { return self_url_; }
 
   // Returns virtual file path representing this file system entry. This path
   // corresponds to file path expected by public methods of GDataFileSyste
   // class.
   FilePath GetFilePath();
 
+  // Restores |file_name_| to the original file name before de-duplication.
+  virtual void UseOriginalFileName();

[satorux1, 2012/03/13 06:03:30]

I got confused about this one. As chatted offline, confusion mainly comes from
the function name, and the fact it's hard to tell the difference between
|file_name| and |original_file_name| from the variable names alone. 

original_file_name_ is now coming from "title" field, so renaming it to |title|
would make it clearer and more accurate.

UseOriginalFileName() would be replaced by something like

// Gets the file name from |title_|.
// Note that Suffixes like "(2)" for files with duplicate names are added
// by AddFile(), not by this function.
FilePath GetFileNameFromTitle();

And the function will be used like:

file_name_ = GetFileNameFromTitle();

[Ben Chan, 2012/03/13 06:28:12]

Done.

+
  protected:
+  // GDataDirectory::TakeFile() needs to call GDataFileBase::set_parent().

[Ben Chan, 2012/03/12 21:45:59]

Couldn't figure out how to only friend the set_parent method when GDataDirectory
is forward-declared, so friend the entire class here.

+  friend class GDataDirectory;
+
+  // Sets the parent directory of this file system entry.
+  // It is intended to be used by GDataDirectory::TakeFile() only.
+  void set_parent(GDataDirectory* parent) { parent_ = parent; }
+
   base::PlatformFileInfo file_info_;
+  // Name of this file in the gdata virtual file system.
   FilePath::StringType file_name_;
+  // Original name of this file, which is used to refer to the 'title' of
+  // a regular file or hosted document. The original name may be different
+  // from |file_name_| due to the added .g<something> extension for hosted
+  // documents or name de-duplication on the gdata file system.
   FilePath::StringType original_file_name_;
+  std::string resource_id_;
   // Files with the same original name 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 self_url_;
   GURL content_url_;
   GDataDirectory* parent_;
   GDataRootDirectory* root_;  // Weak pointer to GDataRootDirectory.
 
  private:
@@ skipping 19 matching lines @@
   virtual GDataFile* AsGDataFile() OVERRIDE;
 
   static GDataFileBase* FromDocumentEntry(GDataDirectory* parent,
                                           DocumentEntry* doc);
 
   DocumentEntry::EntryKind kind() const { return kind_; }
   const GURL& thumbnail_url() const { return thumbnail_url_; }
   const GURL& edit_url() const { return edit_url_; }
   const std::string& content_mime_type() const { return content_mime_type_; }
   const std::string& etag() const { return etag_; }
-  const std::string& resource() const { return resource_id_; }
   const std::string& id() const { return id_; }
   const std::string& file_md5() const { return file_md5_; }
   // Returns a bitmask of CacheState enum values.
   int GetCacheState();
+  const std::string& document_extension() const { return document_extension_; }
   bool is_hosted_document() const { return is_hosted_document_; }
 
+  // GDataFileBase override.
+  virtual void UseOriginalFileName() OVERRIDE;
+
  private:
   // Content URL for files.
   DocumentEntry::EntryKind kind_;
   GURL thumbnail_url_;
   GURL edit_url_;
   std::string content_mime_type_;
   std::string etag_;
-  std::string resource_id_;
   std::string id_;
   std::string file_md5_;
+  std::string document_extension_;
   bool is_hosted_document_;
 
   DISALLOW_COPY_AND_ASSIGN(GDataFile);
 };
 
 // Represents "directory" in a GData virtual file system. Maps to gdata
 // collection element.
 class GDataDirectory : public GDataFileBase {
  public:
   explicit GDataDirectory(GDataDirectory* parent);
   virtual ~GDataDirectory();
   virtual GDataDirectory* AsGDataDirectory() OVERRIDE;
 
   static GDataFileBase* FromDocumentEntry(GDataDirectory* parent,
                                           DocumentEntry* doc);
 
   // Adds child file to the directory and takes over the ownership of |file|
-  // object. The method will also do name deduplication to ensure that the
+  // 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 AddFile(GDataFileBase* file);
 
-  // Removes the file from its children list.
+  // Takes the ownership of |file| 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 TakeFile(GDataFileBase* file);
+
+  // Removes the file from its children list and destroys the file instance.
   bool RemoveFile(GDataFileBase* file);
 
   // Removes children elements.
   void RemoveChildren();
 
   // Checks if directory content needs to be retrieved again. If it does,
   // the function will return URL for next feed in |next_feed_url|.
   bool NeedsRefresh(GURL* next_feed_url);
 
   // 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 GDataFileBase items.
   const GDataFileCollection& children() const { return children_; }
 
  private:
+  // Removes the file from its children list without destroying the
+  // file instance.
+  bool RemoveFileFromChildrenList(GDataFileBase* file);
+
   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_;
   // Collection of children GDataFileBase items.
   GDataFileCollection children_;
@@ skipping 81 matching lines @@
   ResourceMap resource_map_;
 
   CacheMap cache_map_;
 
   DISALLOW_COPY_AND_ASSIGN(GDataRootDirectory);
 };
 
 }  // namespace gdata
 
 #endif  // CHROME_BROWSER_CHROMEOS_GDATA_GDATA_FILES_H_