Rename GDataDirectoryService to DriveResourceMetadata

chrome/browser/chromeos/gdata/drive_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/drive_files.h"
 
 #include "base/platform_file.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/chromeos/gdata/drive.pb.h"
-#include "chrome/browser/chromeos/gdata/gdata_directory_service.h"
+#include "chrome/browser/chromeos/gdata/drive_resource_metadata.h"
 #include "chrome/browser/chromeos/gdata/gdata_wapi_parser.h"
 #include "net/base/escape.h"
 
 namespace gdata {
 namespace {
 
 const char kSlash[] = "/";
 const char kEscapedSlash[] = "\xE2\x88\x95";
 
 // Extracts resource_id out of edit url.
 std::string ExtractResourceId(const GURL& url) {
   return net::UnescapeURLComponent(url.ExtractFileName(),
                                    net::UnescapeRule::URL_SPECIAL_CHARS);
 }
 
 }  // namespace
 
 // DriveEntry class.
 
-DriveEntry::DriveEntry(GDataDirectoryService* directory_service)
+DriveEntry::DriveEntry(DriveResourceMetadata* resource_metadata)
     : parent_(NULL),
-      directory_service_(directory_service),
+      resource_metadata_(resource_metadata),
       deleted_(false) {
-  DCHECK(directory_service);
+  DCHECK(resource_metadata);
 }
 
 DriveEntry::~DriveEntry() {
 }
 
 DriveFile* DriveEntry::AsDriveFile() {
   return NULL;
 }
 
 DriveDirectory* DriveEntry::AsDriveDirectory() {
@@ skipping 64 matching lines @@
 
 // static
 std::string DriveEntry::UnescapeUtf8FileName(const std::string& input) {
   std::string output = input;
   ReplaceSubstringsAfterOffset(&output, 0, std::string(kEscapedSlash), kSlash);
   return output;
 }
 
 // DriveFile class implementation.
 
-DriveFile::DriveFile(GDataDirectoryService* directory_service)
-    : DriveEntry(directory_service),
+DriveFile::DriveFile(DriveResourceMetadata* resource_metadata)
+    : DriveEntry(resource_metadata),
       kind_(DocumentEntry::UNKNOWN),
       is_hosted_document_(false) {
   file_info_.is_directory = false;
 }
 
 DriveFile::~DriveFile() {
 }
 
 DriveFile* DriveFile::AsDriveFile() {
   return this;
@@ skipping 42 matching lines @@
   if (thumbnail_link)
     thumbnail_url_ = thumbnail_link->href();
 
   const Link* alternate_link = doc.GetLinkByType(Link::ALTERNATE);
   if (alternate_link)
     alternate_url_ = alternate_link->href();
 }
 
 // DriveDirectory class implementation.
 
-DriveDirectory::DriveDirectory(GDataDirectoryService* directory_service)
-    : DriveEntry(directory_service) {
+DriveDirectory::DriveDirectory(DriveResourceMetadata* resource_metadata)
+    : DriveEntry(resource_metadata) {
   file_info_.is_directory = true;
 }
 
 DriveDirectory::~DriveDirectory() {
   RemoveChildren();
 }
 
 DriveDirectory* DriveDirectory::AsDriveDirectory() {
   return this;
 }
@@ skipping 33 matching lines @@
     }
   }
   entry->set_base_name(full_file_name.value());
 
   DVLOG(1) << "AddEntry: dir = " << GetFilePath().value()
            << ", file = " + entry->base_name()
            << ", parent resource = " << entry->parent_resource_id()
            << ", resource = " + entry->resource_id();
 
   // Add entry to resource map.
-  directory_service_->AddEntryToResourceMap(entry);
+  resource_metadata_->AddEntryToResourceMap(entry);
 
   // Setup child and parent links.
   if (entry->AsDriveFile())
     child_files_.insert(std::make_pair(entry->base_name(),
                                        entry->resource_id()));
 
   if (entry->AsDriveDirectory())
     child_directories_.insert(std::make_pair(entry->base_name(),
                                              entry->resource_id()));
   entry->SetParent(this);
 }
 
 void DriveDirectory::TakeOverEntries(DriveDirectory* dir) {
-  for (GDataChildMap::const_iterator iter = dir->child_files_.begin();
+  for (ChildMap::const_iterator iter = dir->child_files_.begin();
        iter != dir->child_files_.end(); ++iter) {
     TakeOverEntry(iter->second);
   }
   dir->child_files_.clear();
 
-  for (GDataChildMap::iterator iter = dir->child_directories_.begin();
+  for (ChildMap::iterator iter = dir->child_directories_.begin();
        iter != dir->child_directories_.end(); ++iter) {
     TakeOverEntry(iter->second);
   }
   dir->child_directories_.clear();
 }
 
 void DriveDirectory::TakeOverEntry(const std::string& resource_id) {
-  DriveEntry* entry = directory_service_->GetEntryByResourceId(resource_id);
+  DriveEntry* entry = resource_metadata_->GetEntryByResourceId(resource_id);
   DCHECK(entry);
-  directory_service_->RemoveEntryFromResourceMap(resource_id);
+  resource_metadata_->RemoveEntryFromResourceMap(resource_id);
   entry->SetParent(NULL);
   AddEntry(entry);
 }
 
 void DriveDirectory::RemoveEntry(DriveEntry* entry) {
   DCHECK(entry);
 
   RemoveChild(entry);
   delete entry;
 }
 
 std::string DriveDirectory::FindChild(
     const FilePath::StringType& file_name) const {
-  GDataChildMap::const_iterator iter = child_files_.find(file_name);
+  ChildMap::const_iterator iter = child_files_.find(file_name);
   if (iter != child_files_.end())
     return iter->second;
 
   iter = child_directories_.find(file_name);
   if (iter != child_directories_.end())
     return iter->second;
 
   return std::string();
 }
 
 void DriveDirectory::RemoveChild(DriveEntry* entry) {
   DCHECK(entry);
 
   const std::string& base_name(entry->base_name());
   // entry must be present in this directory.
   DCHECK_EQ(entry->resource_id(), FindChild(base_name));
   // Remove entry from resource map first.
-  directory_service_->RemoveEntryFromResourceMap(entry->resource_id());
+  resource_metadata_->RemoveEntryFromResourceMap(entry->resource_id());
 
   // Then delete it from tree.
   child_files_.erase(base_name);
   child_directories_.erase(base_name);
 
   entry->SetParent(NULL);
 }
 
 void DriveDirectory::RemoveChildren() {
   RemoveChildFiles();
   RemoveChildDirectories();
 }
 
 void DriveDirectory::RemoveChildFiles() {
   DVLOG(1) << "RemoveChildFiles " << resource_id();
-  for (GDataChildMap::const_iterator iter = child_files_.begin();
+  for (ChildMap::const_iterator iter = child_files_.begin();
        iter != child_files_.end(); ++iter) {
-    DriveEntry* child = directory_service_->GetEntryByResourceId(iter->second);
+    DriveEntry* child = resource_metadata_->GetEntryByResourceId(iter->second);
     DCHECK(child);
-    directory_service_->RemoveEntryFromResourceMap(iter->second);
+    resource_metadata_->RemoveEntryFromResourceMap(iter->second);
     delete child;
   }
   child_files_.clear();
 }
 
 void DriveDirectory::RemoveChildDirectories() {
-  for (GDataChildMap::iterator iter = child_directories_.begin();
+  for (ChildMap::iterator iter = child_directories_.begin();
        iter != child_directories_.end(); ++iter) {
-    DriveDirectory* dir = directory_service_->GetEntryByResourceId(
+    DriveDirectory* dir = resource_metadata_->GetEntryByResourceId(
         iter->second)->AsDriveDirectory();
     DCHECK(dir);
     // Remove directories recursively.
     dir->RemoveChildren();
-    directory_service_->RemoveEntryFromResourceMap(iter->second);
+    resource_metadata_->RemoveEntryFromResourceMap(iter->second);
     delete dir;
   }
   child_directories_.clear();
 }
 
 void DriveDirectory::GetChildDirectoryPaths(std::set<FilePath>* child_dirs) {
-  for (GDataChildMap::const_iterator iter = child_directories_.begin();
+  for (ChildMap::const_iterator iter = child_directories_.begin();
        iter != child_directories_.end(); ++iter) {
-    DriveDirectory* dir = directory_service_->GetEntryByResourceId(
+    DriveDirectory* dir = resource_metadata_->GetEntryByResourceId(
         iter->second)->AsDriveDirectory();
     DCHECK(dir);
     child_dirs->insert(dir->GetFilePath());
     dir->GetChildDirectoryPaths(child_dirs);
   }
 }
 
 // Convert to/from proto.
 
 // static
@@ skipping 87 matching lines @@
   file_specific_info->set_file_md5(file_md5_);
   file_specific_info->set_document_extension(document_extension_);
   file_specific_info->set_is_hosted_document(is_hosted_document_);
 }
 
 void DriveDirectory::FromProto(const DriveDirectoryProto& proto) {
   DCHECK(proto.gdata_entry().file_info().is_directory());
   DCHECK(!proto.gdata_entry().has_file_specific_info());
 
   for (int i = 0; i < proto.child_files_size(); ++i) {
-    scoped_ptr<DriveFile> file(directory_service_->CreateDriveFile());
+    scoped_ptr<DriveFile> file(resource_metadata_->CreateDriveFile());
     file->FromProto(proto.child_files(i));
     AddEntry(file.release());
   }
   for (int i = 0; i < proto.child_directories_size(); ++i) {
-    scoped_ptr<DriveDirectory> dir(directory_service_->CreateDriveDirectory());
+    scoped_ptr<DriveDirectory> dir(resource_metadata_->CreateDriveDirectory());
     dir->FromProto(proto.child_directories(i));
     AddEntry(dir.release());
   }
 
   // The states of the directory should be updated after children are
   // handled successfully, so that incomplete states are not left.
   DriveEntry::FromProto(proto.gdata_entry());
 }
 
 void DriveDirectory::ToProto(DriveDirectoryProto* proto) const {
   DriveEntry::ToProto(proto->mutable_gdata_entry());
   DCHECK(proto->gdata_entry().file_info().is_directory());
 
-  for (GDataChildMap::const_iterator iter = child_files_.begin();
+  for (ChildMap::const_iterator iter = child_files_.begin();
        iter != child_files_.end(); ++iter) {
-    DriveFile* file = directory_service_->GetEntryByResourceId(
+    DriveFile* file = resource_metadata_->GetEntryByResourceId(
         iter->second)->AsDriveFile();
     DCHECK(file);
     file->ToProto(proto->add_child_files());
   }
-  for (GDataChildMap::const_iterator iter = child_directories_.begin();
+  for (ChildMap::const_iterator iter = child_directories_.begin();
        iter != child_directories_.end(); ++iter) {
-    DriveDirectory* dir = directory_service_->GetEntryByResourceId(
+    DriveDirectory* dir = resource_metadata_->GetEntryByResourceId(
         iter->second)->AsDriveDirectory();
     DCHECK(dir);
     dir->ToProto(proto->add_child_directories());
   }
 }
 
 scoped_ptr<DriveEntryProtoVector> DriveDirectory::ToProtoVector() const {
   scoped_ptr<DriveEntryProtoVector> entries(new DriveEntryProtoVector);
   // Use ToProtoFull, as we don't want to include children in |proto|.
-  for (GDataChildMap::const_iterator iter = child_files_.begin();
+  for (ChildMap::const_iterator iter = child_files_.begin();
        iter != child_files_.end(); ++iter) {
     DriveEntryProto proto;
-    directory_service_->GetEntryByResourceId(iter->second)->ToProtoFull(&proto);
+    resource_metadata_->GetEntryByResourceId(iter->second)->ToProtoFull(&proto);
     entries->push_back(proto);
   }
-  for (GDataChildMap::const_iterator iter = child_directories_.begin();
+  for (ChildMap::const_iterator iter = child_directories_.begin();
        iter != child_directories_.end(); ++iter) {
     DriveEntryProto proto;
-    directory_service_->GetEntryByResourceId(iter->second)->ToProtoFull(&proto);
+    resource_metadata_->GetEntryByResourceId(iter->second)->ToProtoFull(&proto);
     entries->push_back(proto);
   }
 
   return entries.Pass();
 }
 
 void DriveEntry::SerializeToString(std::string* serialized_proto) const {
   const DriveFile* file = AsDriveFileConst();
   const DriveDirectory* dir = AsDriveDirectoryConst();
 
   if (file) {
     DriveEntryProto entry_proto;
     file->ToProto(&entry_proto);
     const bool ok = entry_proto.SerializeToString(serialized_proto);
     DCHECK(ok);
   } else if (dir) {
     DriveDirectoryProto dir_proto;
     dir->ToProto(&dir_proto);
     const bool ok = dir_proto.SerializeToString(serialized_proto);
     DCHECK(ok);
   }
 }
 
 }  // namespace gdata