Remove parent* arg from GDataEntry ctor.

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 <leveldb/db.h>
 #include <vector>
 
 #include "base/message_loop_proxy.h"
@@ skipping 62 matching lines @@
 }
 
 EntryInfoPairResult::EntryInfoPairResult() {
 }
 
 EntryInfoPairResult::~EntryInfoPairResult() {
 }
 
 // GDataEntry class.
 
-GDataEntry::GDataEntry(GDataDirectory* parent,
-                       GDataDirectoryService* directory_service)
-    : directory_service_(directory_service),
+GDataEntry::GDataEntry(GDataDirectoryService* directory_service)
+    : parent_(NULL),
+      directory_service_(directory_service),
       deleted_(false) {
-  SetParent(parent);
 }
 
 GDataEntry::~GDataEntry() {
 }
 
 GDataFile* GDataEntry::AsGDataFile() {
   return NULL;
 }
 
 GDataDirectory* GDataEntry::AsGDataDirectory() {
   return NULL;
 }
 
+void GDataEntry::InitFromDocumentEntry(DocumentEntry* doc) {
+  // 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.
+  title_ = UTF16ToUTF8(doc->title());
+  // SetBaseNameFromTitle() must be called after |title_| is set.
+  SetBaseNameFromTitle();
+
+  file_info_.last_modified = doc->updated_time();
+  file_info_.last_accessed = doc->updated_time();
+  file_info_.creation_time = doc->published_time();
+
+  resource_id_ = doc->resource_id();
+  content_url_ = doc->content_url();
+  deleted_ = doc->deleted();
+
+  const Link* edit_link = doc->GetLinkByType(Link::EDIT);
+  if (edit_link)
+    edit_url_ = edit_link->href();
+
+  const Link* parent_link = doc->GetLinkByType(Link::PARENT);
+  if (parent_link)
+    parent_resource_id_ = ExtractResourceId(parent_link->href());
+}
+
 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;
   if (parent())
     path = parent()->GetFilePath();
   path = path.Append(base_name());
   return path;
 }
 
 void GDataEntry::SetParent(GDataDirectory* parent) {
   parent_ = parent;
   parent_resource_id_ = parent ? parent->resource_id() : "";
 }
 
 void GDataEntry::SetBaseNameFromTitle() {
   base_name_ = EscapeUtf8FileName(title_);
 }
 
 // static
-GDataEntry* GDataEntry::FromDocumentEntry(
-    GDataDirectory* parent,
-    DocumentEntry* doc,
-    GDataDirectoryService* directory_service) {
-  DCHECK(doc);
-  if (doc->is_folder())
-    return GDataDirectory::FromDocumentEntry(parent, doc, directory_service);
-  else if (doc->is_hosted_document() || doc->is_file())
-    return GDataFile::FromDocumentEntry(parent, doc, directory_service);
-
-  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,
-                     GDataDirectoryService* directory_service)
-    : GDataEntry(parent, directory_service),
+GDataFile::GDataFile(GDataDirectoryService* directory_service)
+    : GDataEntry(directory_service),
       kind_(DocumentEntry::UNKNOWN),
       is_hosted_document_(false) {
   file_info_.is_directory = false;
 }
 
 GDataFile::~GDataFile() {
 }
 
 GDataFile* GDataFile::AsGDataFile() {
   return this;
 }
 
 void GDataFile::SetBaseNameFromTitle() {
   if (is_hosted_document_) {
     base_name_ = EscapeUtf8FileName(title_ + document_extension_);
   } else {
     GDataEntry::SetBaseNameFromTitle();
   }
 }
 
-// static
-GDataEntry* GDataFile::FromDocumentEntry(
-    GDataDirectory* parent,
-    DocumentEntry* doc,
-    GDataDirectoryService* directory_service) {
-  DCHECK(doc->is_hosted_document() || doc->is_file());
-  GDataFile* file = new GDataFile(parent, directory_service);
-
-  // 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());
+void GDataFile::InitFromDocumentEntry(DocumentEntry* doc) {
+  GDataEntry::InitFromDocumentEntry(doc);
 
   // Check if this entry is a true file, or...
   if (doc->is_file()) {
-    file->file_info_.size = doc->file_size();
-    file->file_md5_ = doc->file_md5();
+    file_info_.size = doc->file_size();
+    file_md5_ = doc->file_md5();
 
     // The resumable-edit-media link should only be present for regular
     // files as hosted documents are not uploadable.
     const Link* upload_link = doc->GetLinkByType(Link::RESUMABLE_EDIT_MEDIA);
     if (upload_link)
-      file->upload_url_ = upload_link->href();
+      upload_url_ = upload_link->href();
   } else {
     // ... a hosted document.
     // Attach .g<something> extension to hosted documents so we can special
     // case their handling in UI.
     // TODO(zelidrag): Figure out better way how to pass entry info like kind
     // to UI through the File API stack.
-    file->document_extension_ = doc->GetHostedDocumentExtension();
+    document_extension_ = doc->GetHostedDocumentExtension();
     // We don't know the size of hosted docs and it does not matter since
     // is has no effect on the quota.
-    file->file_info_.size = 0;
+    file_info_.size = 0;
   }
-  file->kind_ = doc->kind();
-  const Link* edit_link = doc->GetLinkByType(Link::EDIT);
-  if (edit_link)
-    file->edit_url_ = edit_link->href();
-  file->content_url_ = doc->content_url();
-  file->content_mime_type_ = doc->content_mime_type();
-  file->resource_id_ = doc->resource_id();
-  file->is_hosted_document_ = doc->is_hosted_document();
-  file->file_info_.last_modified = doc->updated_time();
-  file->file_info_.last_accessed = doc->updated_time();
-  file->file_info_.creation_time = doc->published_time();
-  file->deleted_ = doc->deleted();
-  const Link* parent_link = doc->GetLinkByType(Link::PARENT);
-  if (parent_link)
-    file->parent_resource_id_ = ExtractResourceId(parent_link->href());
-
+  kind_ = doc->kind();
+  content_mime_type_ = doc->content_mime_type();
+  is_hosted_document_ = doc->is_hosted_document();
   // SetBaseNameFromTitle() must be called after |title_|,
   // |is_hosted_document_| and |document_extension_| are set.
-  file->SetBaseNameFromTitle();
+  SetBaseNameFromTitle();
 
   const Link* thumbnail_link = doc->GetLinkByType(Link::THUMBNAIL);
   if (thumbnail_link)
-    file->thumbnail_url_ = thumbnail_link->href();
+    thumbnail_url_ = thumbnail_link->href();
 
   const Link* alternate_link = doc->GetLinkByType(Link::ALTERNATE);
   if (alternate_link)
-    file->alternate_url_ = alternate_link->href();
-
-  return file;
+    alternate_url_ = alternate_link->href();
 }
 
 // GDataDirectory class implementation.
 
-GDataDirectory::GDataDirectory(GDataDirectory* parent,
-                               GDataDirectoryService* directory_service)
-    : GDataEntry(parent, directory_service) {
+GDataDirectory::GDataDirectory(GDataDirectoryService* directory_service)
+    : GDataEntry(directory_service) {
   file_info_.is_directory = true;
 }
 
 GDataDirectory::~GDataDirectory() {
   RemoveChildren();
 }
 
 GDataDirectory* GDataDirectory::AsGDataDirectory() {
   return this;
 }
 
-// static
-GDataEntry* GDataDirectory::FromDocumentEntry(
-    GDataDirectory* parent,
-    DocumentEntry* doc,
-    GDataDirectoryService* directory_service) {
-  DCHECK(doc->is_folder());
-  GDataDirectory* dir = new GDataDirectory(parent, directory_service);
-  dir->title_ = UTF16ToUTF8(doc->title());
-  // SetBaseNameFromTitle() must be called after |title_| is set.
-  dir->SetBaseNameFromTitle();
-  dir->file_info_.last_modified = doc->updated_time();
-  dir->file_info_.last_accessed = doc->updated_time();
-  dir->file_info_.creation_time = doc->published_time();
-  dir->resource_id_ = doc->resource_id();
-  dir->content_url_ = doc->content_url();
-  dir->deleted_ = doc->deleted();
-
-  const Link* edit_link = doc->GetLinkByType(Link::EDIT);
-  DCHECK(edit_link) << "No edit link for dir " << dir->title_;
-  if (edit_link)
-    dir->edit_url_ = edit_link->href();
-
-  const Link* parent_link = doc->GetLinkByType(Link::PARENT);
-  if (parent_link)
-    dir->parent_resource_id_ = ExtractResourceId(parent_link->href());
+void GDataDirectory::InitFromDocumentEntry(DocumentEntry* doc) {
+  GDataEntry::InitFromDocumentEntry(doc);
 
   const Link* upload_link = doc->GetLinkByType(Link::RESUMABLE_CREATE_MEDIA);
   if (upload_link)
-    dir->upload_url_ = upload_link->href();
-
-  return dir;
+    upload_url_ = upload_link->href();
 }
 
 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->SetBaseNameFromTitle();
 
   // Do file name de-duplication - find files with the same name and
   // append a name modifier to the name.
@@ skipping 239 matching lines @@
 }
 
 // GDataDirectoryService class implementation.
 
 GDataDirectoryService::GDataDirectoryService()
     : blocking_task_runner_(NULL),
       serialized_size_(0),
       largest_changestamp_(0),
       origin_(UNINITIALIZED),
       weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
-  root_.reset(new GDataDirectory(NULL, this));
+  root_.reset(CreateGDataDirectory());
   if (!util::IsDriveV2ApiEnabled())
     InitializeRootEntry(kGDataRootDirectoryResourceId);
 }
 
 GDataDirectoryService::~GDataDirectoryService() {
   ClearRoot();
 
   // Ensure db is closed on the blocking pool.
   if (blocking_task_runner_ && directory_service_db_.get())
     blocking_task_runner_->DeleteSoon(FROM_HERE,
                                       directory_service_db_.release());
 }
 
+GDataEntry* GDataDirectoryService::FromDocumentEntry(DocumentEntry* doc) {
+  DCHECK(doc);
+  GDataEntry* entry = NULL;
+  if (doc->is_folder())
+    entry = CreateGDataDirectory();
+  else if (doc->is_hosted_document() || doc->is_file())
+    entry = CreateGDataFile();
+
+  if (entry)
+    entry->InitFromDocumentEntry(doc);

[satorux1, 2012/08/10 00:45:27]

because InitFromDocumentEntry() is virtual,
GDataDirectory::InitFromDocumentEntry is called if |entry| was created by
CreateGDataFile() right?

[achuithb, 2012/08/10 08:42:00]

Yup. The correct InitFromDocumentEntry is called due to dynamic/virtual
dispatch. GDataDirectory::InitFromDocumentEntry for CreateGDataDirectory and
GDataFile::InitFromDocumentEntry for CreateGDataFile. 

+  return entry;
+}
+
+GDataFile* GDataDirectoryService::CreateGDataFile() {
+  return new GDataFile(this);
+}
+
+GDataDirectory* GDataDirectoryService::CreateGDataDirectory() {
+  return new GDataDirectory(this);
+}
+
 void GDataDirectoryService::InitializeRootEntry(const std::string& root_id) {
-  root_.reset(new GDataDirectory(NULL, this));
+  root_.reset(CreateGDataDirectory());
   root_->set_title(kGDataRootDirectory);
   root_->SetBaseNameFromTitle();
   root_->set_resource_id(root_id);
   AddEntryToResourceMap(root_.get());
 }
 
 void GDataDirectoryService::ClearRoot() {
   // Note that children have a reference to root_,
   // so we need to delete them here.
   root_->RemoveChildren();
@@ skipping 447 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_);
 }
 
 bool GDataDirectory::FromProto(const GDataDirectoryProto& 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<GDataFile> file(new GDataFile(NULL, directory_service_));
+    scoped_ptr<GDataFile> file(directory_service_->CreateGDataFile());
     if (!file->FromProto(proto.child_files(i))) {
       RemoveChildren();
       return false;
     }
     AddEntry(file.release());
   }
   for (int i = 0; i < proto.child_directories_size(); ++i) {
-    scoped_ptr<GDataDirectory> dir(new GDataDirectory(NULL,
-                                                      directory_service_));
+    scoped_ptr<GDataDirectory> dir(directory_service_->CreateGDataDirectory());
     if (!dir->FromProto(proto.child_directories(i))) {
       RemoveChildren();
       return false;
     }
     AddEntry(dir.release());
   }
 
   // The states of the directory should be updated after children are
   // handled successfully, so that incomplete states are not left.
   if (!GDataEntry::FromProto(proto.gdata_entry()))
@@ skipping 92 matching lines @@
 }
 
 scoped_ptr<GDataEntry> GDataDirectoryService::FromProtoString(
     const std::string& serialized_proto) {
   GDataEntryProto entry_proto;
   if (!entry_proto.ParseFromString(serialized_proto))
     return scoped_ptr<GDataEntry>();
 
   scoped_ptr<GDataEntry> entry;
   if (entry_proto.file_info().is_directory()) {
-    entry.reset(new GDataDirectory(NULL, this));
+    entry.reset(CreateGDataDirectory());
     // Call GDataEntry::FromProto instead of GDataDirectory::FromProto because
     // the proto does not include children.
     if (!entry->FromProto(entry_proto)) {
       NOTREACHED() << "FromProto (directory) failed";
       entry.reset();
     }
   } else {
-    scoped_ptr<GDataFile> file(new GDataFile(NULL, this));
+    scoped_ptr<GDataFile> file(CreateGDataFile());
     // Call GDataFile::FromProto.
     if (file->FromProto(entry_proto)) {
       entry.reset(file.release());
     } else {
       NOTREACHED() << "FromProto (file) failed";
     }
   }
   return entry.Pass();
 }
 
@@ skipping 38 matching lines @@
   DCHECK(result.get());
 
   result->second.path = second_path;
   result->second.error = error;
   result->second.proto = entry_proto.Pass();
 
   callback.Run(result.Pass());
 }
 
 }  // namespace gdata