Parent/child fixes.

chrome/browser/chromeos/gdata/gdata_files.cc

 // 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.
 
 #include "chrome/browser/chromeos/gdata/gdata_files.h"
 
 #include <vector>
 
 #include "base/utf_string_conversions.h"
 #include "base/platform_file.h"
 #include "base/stringprintf.h"
 #include "base/string_util.h"
 #include "chrome/browser/chromeos/gdata/find_entry_delegate.h"
 #include "chrome/browser/chromeos/gdata/gdata.pb.h"
 #include "chrome/browser/chromeos/gdata/gdata_parser.h"
 #include "net/base/escape.h"
 
+namespace gdata {
 namespace {
 
 // Content refresh time.
 #ifndef NDEBUG
 const int kRefreshTimeInSec = 10;
 #else
 const int kRefreshTimeInSec = 5*60;
 #endif
 
 const char kSlash[] = "/";
 const char kEscapedSlash[] = "\xE2\x88\x95";
+const FilePath::CharType kGDataRootDirectory[] = FILE_PATH_LITERAL("gdata");
 
 std::string CacheSubDirectoryTypeToString(
-    gdata::GDataRootDirectory::CacheSubDirectoryType subdir) {
+    GDataRootDirectory::CacheSubDirectoryType subdir) {
   switch (subdir) {
-    case gdata::GDataRootDirectory::CACHE_TYPE_META: return "meta";
-    case gdata::GDataRootDirectory::CACHE_TYPE_PINNED: return "pinned";
-    case gdata::GDataRootDirectory::CACHE_TYPE_OUTGOING: return "outgoing";
-    case gdata::GDataRootDirectory::CACHE_TYPE_PERSISTENT: return "persistent";
-    case gdata::GDataRootDirectory::CACHE_TYPE_TMP: return "tmp";
-    case gdata::GDataRootDirectory::CACHE_TYPE_TMP_DOWNLOADS:
+    case GDataRootDirectory::CACHE_TYPE_META: return "meta";
+    case GDataRootDirectory::CACHE_TYPE_PINNED: return "pinned";
+    case GDataRootDirectory::CACHE_TYPE_OUTGOING: return "outgoing";
+    case GDataRootDirectory::CACHE_TYPE_PERSISTENT: return "persistent";
+    case GDataRootDirectory::CACHE_TYPE_TMP: return "tmp";
+    case GDataRootDirectory::CACHE_TYPE_TMP_DOWNLOADS:
       return "tmp_downloads";
-    case gdata::GDataRootDirectory::CACHE_TYPE_TMP_DOCUMENTS:
+    case GDataRootDirectory::CACHE_TYPE_TMP_DOCUMENTS:
       return "tmp_documents";
-    case gdata::GDataRootDirectory::NUM_CACHE_TYPES:
+    case GDataRootDirectory::NUM_CACHE_TYPES:
       NOTREACHED();
   }
   NOTREACHED();
   return "unknown subdir";
 }
 
 // Extracts resource_id out of edit url.
 std::string ExtractResourceId(const GURL& url) {
   return net::UnescapeURLComponent(url.ExtractFileName(),
                                    net::UnescapeRule::URL_SPECIAL_CHARS);
 }
 
 }  // namespace
 
-namespace gdata {
-
 // GDataEntry class.
 
 GDataEntry::GDataEntry(GDataDirectory* parent, GDataRootDirectory* root)
-    : parent_(parent),
-      root_(root),
+    : root_(root),
       deleted_(false) {
+  SetParent(parent);
 }
 
 GDataEntry::~GDataEntry() {
 }
 
 GDataFile* GDataEntry::AsGDataFile() {
   return NULL;
 }
 
 GDataDirectory* GDataEntry::AsGDataDirectory() {
   return NULL;
 }
 
 GDataRootDirectory* GDataEntry::AsGDataRootDirectory() {
   return NULL;
 }
 
 const GDataFile* GDataEntry::AsGDataFileConst() const {
   // cast away const and call the non-const version. This is safe.
   return const_cast<GDataEntry*>(this)->AsGDataFile();
 }
 
 const GDataDirectory* GDataEntry::AsGDataDirectoryConst() const {
   // cast away const and call the non-const version. This is safe.
   return const_cast<GDataEntry*>(this)->AsGDataDirectory();
 }
 
 FilePath GDataEntry::GetFilePath() const {
   FilePath path;
-  std::vector<FilePath::StringType> parts;
-  for (const GDataEntry* entry = this; entry != NULL; entry = entry->parent_)
-    parts.push_back(entry->file_name());
+  if (parent())
+    path = parent()->GetFilePath();
+  path = path.Append(file_name());
+  return path;
+}
 
-  // Paste paths parts back together in reverse order from upward tree
-  // traversal.
-  for (std::vector<FilePath::StringType>::reverse_iterator iter =
-           parts.rbegin();
-       iter != parts.rend(); ++iter) {
-    path = path.Append(*iter);
-  }
-  return path;
+void GDataEntry::SetParent(GDataDirectory* parent) {
+  parent_ = parent;
+  parent_resource_id_ = parent ? parent->resource_id() : "";

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

IIRC, parent_resource_id_ was used for delta updates. not sure if inheriting
this from here is the right thing to do.

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

I think it is. It should always point to the correct parent. Zel can chime in
here.

 }
 
 void GDataEntry::SetFileNameFromTitle() {
   file_name_ = EscapeUtf8FileName(title_);
 }
 
 // static.
 GDataEntry* GDataEntry::FromDocumentEntry(GDataDirectory* parent,
-                                                DocumentEntry* doc,
-                                                GDataRootDirectory* root) {
+                                          DocumentEntry* doc,
+                                          GDataRootDirectory* root) {
   DCHECK(doc);
   if (doc->is_folder())
     return GDataDirectory::FromDocumentEntry(parent, doc, root);
   else if (doc->is_hosted_document() || doc->is_file())
     return GDataFile::FromDocumentEntry(parent, doc, root);
 
   return NULL;
 }
 
 // static.
 std::string GDataEntry::EscapeUtf8FileName(const std::string& input) {
   std::string output;
   if (ReplaceChars(input, kSlash, std::string(kEscapedSlash), &output))
     return output;
 
   return input;
 }
 
 // static.
 std::string GDataEntry::UnescapeUtf8FileName(const std::string& input) {
   std::string output = input;
   ReplaceSubstringsAfterOffset(&output, 0, std::string(kEscapedSlash), kSlash);
   return output;
 }
 
 // GDataFile class implementation.
 
 GDataFile::GDataFile(GDataDirectory* parent, GDataRootDirectory* root)
     : GDataEntry(parent, root),
-      kind_(gdata::DocumentEntry::UNKNOWN),
+      kind_(DocumentEntry::UNKNOWN),
       is_hosted_document_(false) {
   file_info_.is_directory = false;
 }
 
 GDataFile::~GDataFile() {
 }
 
 GDataFile* GDataFile::AsGDataFile() {
   return this;
 }
 
 void GDataFile::SetFileNameFromTitle() {
   if (is_hosted_document_) {
     file_name_ = EscapeUtf8FileName(title_ + document_extension_);
   } else {
     GDataEntry::SetFileNameFromTitle();
   }
 }
 
 // static.
 GDataEntry* GDataFile::FromDocumentEntry(GDataDirectory* parent,
-                                            DocumentEntry* doc,
-                                            GDataRootDirectory* root) {
+                                         DocumentEntry* doc,
+                                         GDataRootDirectory* root) {
   DCHECK(doc->is_hosted_document() || doc->is_file());
   GDataFile* file = new GDataFile(parent, root);
 
   // For regular files, the 'filename' and 'title' attribute in the metadata
   // may be different (e.g. due to rename). To be consistent with the web
   // interface and other client to use the 'title' attribute, instead of
   // 'filename', as the file name in the local snapshot.
   file->title_ = UTF16ToUTF8(doc->title());
 
   // Check if this entry is a true file, or...
@@ skipping 55 matching lines @@
 GDataDirectory::~GDataDirectory() {
   RemoveChildren();
 }
 
 GDataDirectory* GDataDirectory::AsGDataDirectory() {
   return this;
 }
 
 // static
 GDataEntry* GDataDirectory::FromDocumentEntry(GDataDirectory* parent,
-                                                 DocumentEntry* doc,
-                                                 GDataRootDirectory* root) {
+                                              DocumentEntry* doc,
+                                              GDataRootDirectory* root) {
   DCHECK(doc->is_folder());
   GDataDirectory* dir = new GDataDirectory(parent, root);
   dir->title_ = UTF16ToUTF8(doc->title());
   // SetFileNameFromTitle() must be called after |title_| is set.
   dir->SetFileNameFromTitle();
   dir->file_info_.last_modified = doc->updated_time();
   dir->file_info_.last_accessed = doc->updated_time();
   dir->file_info_.creation_time = doc->published_time();
   // Extract feed link.
   dir->start_feed_url_ = doc->content_url();
@@ skipping 10 matching lines @@
   if (parent_link)
     dir->parent_resource_id_ = ExtractResourceId(parent_link->href());
 
   const Link* upload_link = doc->GetLinkByType(Link::RESUMABLE_CREATE_MEDIA);
   if (upload_link)
     dir->upload_url_ = upload_link->href();
 
   return dir;
 }
 
-void GDataDirectory::RemoveChildren() {
-  // Remove children from resource map first.
-  root_->RemoveEntriesFromResourceMap(children_);
-
-  // Then delete and remove the children from tree.
-  STLDeleteValues(&children_);
-  children_.clear();
-}
-
 bool GDataDirectory::NeedsRefresh() const {
   // Already refreshing by someone else.
   if (origin_ == REFRESHING)
     return false;
 
   // Refresh is needed for content read from disk cache or stale content.
   if (origin_ == FROM_CACHE)
     return true;
 
   if ((base::Time::Now() - refresh_time_).InSeconds() < kRefreshTimeInSec)
     return false;
 
   return true;
 }
 
 void GDataDirectory::AddEntry(GDataEntry* entry) {
+  // The entry name may have been changed due to prior name de-duplication.
+  // We need to first restore the file name based on the title before going
+  // through name de-duplication again when it is added to another directory.
+  entry->SetFileNameFromTitle();
+
   // Do file name de-duplication - find files with the same name and
   // append a name modifier to the name.
   int max_modifier = 1;
   FilePath full_file_name(entry->file_name());
-  std::string extension = full_file_name.Extension();
-  std::string file_name = full_file_name.RemoveExtension().value();
-  while (children_.find(full_file_name.value()) !=  children_.end()) {
+  const std::string extension = full_file_name.Extension();
+  const std::string file_name = full_file_name.RemoveExtension().value();
+  while (FindChild(full_file_name.value())) {
     if (!extension.empty()) {
       full_file_name = FilePath(base::StringPrintf("%s (%d)%s",
                                                    file_name.c_str(),
                                                    ++max_modifier,
                                                    extension.c_str()));
     } else {
       full_file_name = FilePath(base::StringPrintf("%s (%d)",
                                                    file_name.c_str(),
                                                    ++max_modifier));
     }
   }
-  if (full_file_name.value() != entry->file_name())
-    entry->set_file_name(full_file_name.value());
-  children_.insert(std::make_pair(entry->file_name(), entry));
-  DVLOG(1) << "Adding: "
-           << this->GetFilePath().value()
-           << "/" + entry->file_name()
-           << ", resource " << entry->parent_resource_id()
-           << "/" + entry->resource_id();
+  entry->set_file_name(full_file_name.value());
+
+  DVLOG(1) << "AddEntry: dir = " << GetFilePath().value()
+           << ", file = " + entry->file_name()
+           << ", parent resource = " << entry->parent_resource_id()
+           << ", resource = " + entry->resource_id();
+
 
   // Add entry to resource map.
   root_->AddEntryToResourceMap(entry);
-
-  entry->set_parent(this);
+  // Setup child and parent links.
+  AddChild(entry);
+  entry->SetParent(this);
 }
 
 bool GDataDirectory::TakeEntry(GDataEntry* entry) {
   DCHECK(entry);
   DCHECK(entry->parent());
 
-  entry->parent()->RemoveEntryFromChildrenList(entry);
-
-  // The entry name may have been changed due to prior name de-duplication.
-  // We need to first restore the file name based on the title before going
-  // through name de-duplication again when it is added to another directory.
-  entry->SetFileNameFromTitle();
+  entry->parent()->RemoveChild(entry);
   AddEntry(entry);
 
   return true;
 }
 
 bool GDataDirectory::TakeOverEntries(GDataDirectory* dir) {
-  for (GDataFileCollection::iterator iter = dir->children_.begin();
-       iter != dir->children_.end(); ++iter) {
-    GDataEntry* entry = iter->second;
-    entry->SetFileNameFromTitle();
-    AddEntry(entry);
+  for (GDataFileCollection::iterator iter = dir->child_files_.begin();
+       iter != dir->child_files_.end(); ++iter) {
+    AddEntry(iter->second);
   }
-  dir->children_.clear();
+  dir->child_files_.clear();
+
+  for (GDataDirectoryCollection::iterator iter =
+      dir->child_directories_.begin();
+       iter != dir->child_directories_.end(); ++iter) {
+    AddEntry(iter->second);
+  }
+  dir->child_directories_.clear();
   return true;
 }
 
 bool GDataDirectory::RemoveEntry(GDataEntry* entry) {
   DCHECK(entry);
 
-  if (!RemoveEntryFromChildrenList(entry))
+  if (!RemoveChild(entry))
     return false;
 
   delete entry;
   return true;
 }
 
-bool GDataDirectory::RemoveEntryFromChildrenList(GDataEntry* entry) {
+GDataEntry* GDataDirectory::FindChild(
+    const FilePath::StringType& file_name) const {
+  GDataFileCollection::const_iterator it = child_files_.find(file_name);
+  if (it != child_files_.end())
+    return it->second;
+
+  GDataDirectoryCollection::const_iterator itd =
+      child_directories_.find(file_name);
+  if (itd != child_directories_.end())
+    return itd->second;
+
+  return NULL;
+}
+
+void GDataDirectory::AddChild(GDataEntry* entry) {
   DCHECK(entry);
 
-  GDataFileCollection::iterator iter = children_.find(entry->file_name());
-  if (iter == children_.end())
+  GDataFile* file = entry->AsGDataFile();
+  if (file)
+    child_files_.insert(std::make_pair(entry->file_name(), file));
+
+  GDataDirectory* directory = entry->AsGDataDirectory();
+  if (directory)
+    child_directories_.insert(std::make_pair(entry->file_name(), directory));
+}
+
+bool GDataDirectory::RemoveChild(GDataEntry* entry) {
+  DCHECK(entry);
+
+  const std::string file_name(entry->file_name());
+  GDataEntry* found_entry = FindChild(file_name);
+  if (!found_entry)
     return false;
 
-  DCHECK(iter->second);
-  DCHECK_EQ(entry, iter->second);
+  DCHECK_EQ(entry, found_entry);
 
   // Remove entry from resource map first.
   root_->RemoveEntryFromResourceMap(entry);
 
   // Then delete it from tree.
-  children_.erase(iter);
+  child_files_.erase(file_name);
+  child_directories_.erase(file_name);
 
   return true;
 }
 
+void GDataDirectory::RemoveChildren() {
+  // Remove child files first.
+  for (GDataFileCollection::const_iterator iter = child_files_.begin();
+       iter != child_files_.end(); ++iter) {
+    root_->RemoveEntryFromResourceMap(iter->second);
+  }
+  STLDeleteValues(&child_files_);
+  child_files_.clear();
+
+  for (GDataDirectoryCollection::iterator iter = child_directories_.begin();
+       iter != child_directories_.end(); ++iter) {
+    GDataDirectory* dir = iter->second;
+    // Remove directories recursively.
+    dir->RemoveChildren();
+    root_->RemoveEntryFromResourceMap(dir);
+  }
+  STLDeleteValues(&child_directories_);
+  child_directories_.clear();
+}
+
 // GDataRootDirectory::CacheEntry struct  implementation.
 
 std::string GDataRootDirectory::CacheEntry::ToString() const {
   std::vector<std::string> cache_states;
   if (GDataFile::IsCachePresent(cache_state))
     cache_states.push_back("present");
   if (GDataFile::IsCachePinned(cache_state))
     cache_states.push_back("pinned");
   if (GDataFile::IsCacheDirty(cache_state))
     cache_states.push_back("dirty");
 
   return base::StringPrintf("md5=%s, subdir=%s, cache_state=%s",
                             md5.c_str(),
                             CacheSubDirectoryTypeToString(sub_dir_type).c_str(),
                             JoinString(cache_states, ',').c_str());
 }
 
 // GDataRootDirectory class implementation.
 
 GDataRootDirectory::GDataRootDirectory()
     : ALLOW_THIS_IN_INITIALIZER_LIST(GDataDirectory(NULL, this)),
       largest_changestamp_(0), serialized_size_(0) {
+  title_ = kGDataRootDirectory;
+  SetFileNameFromTitle();
 }
 
 GDataRootDirectory::~GDataRootDirectory() {
   STLDeleteValues(&cache_map_);
   cache_map_.clear();
 
   resource_map_.clear();
 }
 
 GDataRootDirectory* GDataRootDirectory::AsGDataRootDirectory() {
   return this;
 }
 
 void GDataRootDirectory::AddEntryToResourceMap(GDataEntry* entry) {
   // GDataFileSystem has already locked.
+  DVLOG(1) << "AddEntryToResourceMap " << entry->resource_id();
   resource_map_.insert(std::make_pair(entry->resource_id(), entry));
 }
 
 void GDataRootDirectory::RemoveEntryFromResourceMap(GDataEntry* entry) {
   // GDataFileSystem has already locked.
   resource_map_.erase(entry->resource_id());
 }
 
-void GDataRootDirectory::RemoveEntriesFromResourceMap(
-    const GDataFileCollection& children) {
-  // GDataFileSystem has already locked.
-  for (GDataFileCollection::const_iterator iter = children.begin();
-       iter != children.end(); ++iter) {
-    // Recursively call RemoveEntrysFromResourceMap for each directory.
-    if (iter->second->AsGDataDirectory()) {
-      RemoveEntriesFromResourceMap(
-          iter->second->AsGDataDirectory()->children());
-      continue;
-    }
-
-    resource_map_.erase(iter->second->resource_id());
-  }
-}
-
 void GDataRootDirectory::FindEntryByPath(
     const FilePath& file_path,
     FindEntryDelegate* delegate) {
   // GDataFileSystem has already locked.
   DCHECK(delegate);
 
   std::vector<FilePath::StringType> components;
   file_path.GetComponents(&components);
 
   GDataDirectory* current_dir = this;
   FilePath directory_path;
   for (size_t i = 0; i < components.size() && current_dir; i++) {
     directory_path = directory_path.Append(current_dir->file_name());
 
     // Last element must match, if not last then it must be a directory.
     if (i == components.size() - 1) {
       if (current_dir->file_name() == components[i])
         delegate->OnDone(base::PLATFORM_FILE_OK, directory_path, current_dir);
       else
         delegate->OnDone(base::PLATFORM_FILE_ERROR_NOT_FOUND, FilePath(), NULL);
 
       return;
     }
 
     // Not the last part of the path, search for the next segment.
-    GDataFileCollection::const_iterator file_iter =
-        current_dir->children().find(components[i + 1]);
-    if (file_iter == current_dir->children().end()) {
+    GDataEntry* entry = current_dir->FindChild(components[i + 1]);
+    if (!entry) {
       delegate->OnDone(base::PLATFORM_FILE_ERROR_NOT_FOUND, FilePath(), NULL);
       return;
     }
 
     // Found file, must be the last segment.
-    if (file_iter->second->file_info().is_directory) {
+    if (entry->file_info().is_directory) {
       // Found directory, continue traversal.
-      current_dir = file_iter->second->AsGDataDirectory();
+      current_dir = entry->AsGDataDirectory();
     } else {
       if ((i + 1) == (components.size() - 1)) {
         delegate->OnDone(base::PLATFORM_FILE_OK,
                          directory_path,
-                         file_iter->second);
+                         entry);
       } else {
         delegate->OnDone(base::PLATFORM_FILE_ERROR_NOT_FOUND, FilePath(), NULL);
       }
 
       return;
     }
   }
   delegate->OnDone(base::PLATFORM_FILE_ERROR_NOT_FOUND, FilePath(), NULL);
 }
 
@@ skipping 109 matching lines @@
   file_info_.size = proto.file_info().size();
   file_info_.is_directory = proto.file_info().is_directory();
   file_info_.is_symbolic_link = proto.file_info().is_symbolic_link();
   file_info_.last_modified = base::Time::FromInternalValue(
       proto.file_info().last_modified());
   file_info_.last_accessed = base::Time::FromInternalValue(
       proto.file_info().last_accessed());
   file_info_.creation_time = base::Time::FromInternalValue(
       proto.file_info().creation_time());
 
-  file_name_ = proto.file_name();
   title_ = proto.title();
   resource_id_ = proto.resource_id();
+  parent_resource_id_ = proto.parent_resource_id();
   edit_url_ = GURL(proto.edit_url());
   content_url_ = GURL(proto.content_url());
+  SetFileNameFromTitle();
 }
 
 void GDataEntry::ToProto(GDataEntryProto* proto) const {
   PlatformFileInfoProto* proto_file_info = proto->mutable_file_info();
   proto_file_info->set_size(file_info_.size);
   proto_file_info->set_is_directory(file_info_.is_directory);
   proto_file_info->set_is_symbolic_link(file_info_.is_symbolic_link);
   proto_file_info->set_last_modified(
       file_info_.last_modified.ToInternalValue());
   proto_file_info->set_last_accessed(
       file_info_.last_accessed.ToInternalValue());
   proto_file_info->set_creation_time(
       file_info_.creation_time.ToInternalValue());
 
-  proto->set_file_name(file_name_);
   proto->set_title(title_);
   proto->set_resource_id(resource_id_);
+  proto->set_parent_resource_id(parent_resource_id_);
   proto->set_edit_url(edit_url_.spec());
   proto->set_content_url(content_url_.spec());
 }
 
 void GDataFile::FromProto(const GDataFileProto& proto) {
   DCHECK(!proto.gdata_entry().file_info().is_directory());
   GDataEntry::FromProto(proto.gdata_entry());
   kind_ = DocumentEntry::EntryKind(proto.kind());
   thumbnail_url_ = GURL(proto.thumbnail_url());
   alternate_url_ = GURL(proto.alternate_url());
@@ skipping 40 matching lines @@
 }
 
 void GDataDirectory::ToProto(GDataDirectoryProto* proto) const {
   GDataEntry::ToProto(proto->mutable_gdata_entry());
   DCHECK(proto->gdata_entry().file_info().is_directory());
   proto->set_refresh_time(refresh_time_.ToInternalValue());
   proto->set_start_feed_url(start_feed_url_.spec());
   proto->set_next_feed_url(next_feed_url_.spec());
   proto->set_upload_url(upload_url_.spec());
   proto->set_origin(origin_);
-  for (GDataFileCollection::const_iterator iter = children_.begin();
-       iter != children_.end(); ++iter) {
-    GDataFile* file = iter->second->AsGDataFile();
-    GDataDirectory* dir = iter->second->AsGDataDirectory();
-    if (file)
-      file->ToProto(proto->add_child_files());
-    if (dir)
-      dir->ToProto(proto->add_child_directories());
+  for (GDataFileCollection::const_iterator iter = child_files_.begin();
+       iter != child_files_.end(); ++iter) {
+    GDataFile* file = iter->second;
+    file->ToProto(proto->add_child_files());
+  }
+  for (GDataDirectoryCollection::const_iterator iter =
+       child_directories_.begin();
+       iter != child_directories_.end(); ++iter) {
+    GDataDirectory* dir = iter->second;
+    dir->ToProto(proto->add_child_directories());
   }
 }
 
 void GDataRootDirectory::FromProto(const GDataRootDirectoryProto& proto) {
   root_ = this;
   GDataDirectory::FromProto(proto.gdata_directory());
   largest_changestamp_ = proto.largest_changestamp();
 }
 
 void GDataRootDirectory::ToProto(GDataRootDirectoryProto* proto) const {
@@ skipping 58 matching lines @@
   bool ok = proto->ParseFromString(serialized_proto);
   if (ok) {
     FromProto(*proto.get());
     set_origin(FROM_CACHE);
     set_refresh_time(base::Time::Now());
   }
   return ok;
 }
 
 }  // namespace gdata