Set root resource ID upon full feed update.

chrome/browser/chromeos/drive/drive_resource_metadata.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/drive/drive_resource_metadata.h"
 
 #include <leveldb/db.h>
 #include <utility>
 
 #include "base/message_loop_proxy.h"
@@ skipping 180 matching lines @@
 
 // DriveResourceMetadata class implementation.
 
 DriveResourceMetadata::DriveResourceMetadata()
     : blocking_task_runner_(NULL),
       serialized_size_(0),
       largest_changestamp_(0),
       origin_(UNINITIALIZED),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)) {
   root_ = CreateDriveDirectory().Pass();
-  if (!google_apis::util::IsDriveV2ApiEnabled())
-    InitializeRootEntry(kDriveRootDirectoryResourceId);
+  root_->set_title(kDriveRootDirectory);
+  root_->SetBaseNameFromTitle();
 }
 
 DriveResourceMetadata::~DriveResourceMetadata() {
   ClearRoot();
 
   // Ensure db is closed on the blocking pool.
   if (blocking_task_runner_ && resource_metadata_db_.get())
     blocking_task_runner_->DeleteSoon(FROM_HERE,
                                       resource_metadata_db_.release());
 }
@@ skipping 12 matching lines @@
 }
 
 scoped_ptr<DriveFile> DriveResourceMetadata::CreateDriveFile() {
   return scoped_ptr<DriveFile>(new DriveFile(this));
 }
 
 scoped_ptr<DriveDirectory> DriveResourceMetadata::CreateDriveDirectory() {
   return scoped_ptr<DriveDirectory>(new DriveDirectory(this));
 }
 
-void DriveResourceMetadata::InitializeRootEntry(const std::string& root_id) {
-  root_ = CreateDriveDirectory().Pass();
-  root_->set_title(kDriveRootDirectory);
-  root_->SetBaseNameFromTitle();
-  root_->set_resource_id(root_id);
+void DriveResourceMetadata::SetRootResourceId(const std::string& id) {
+  DCHECK(root_->resource_id().empty());
+  root_->set_resource_id(id);
   AddEntryToResourceMap(root_.get());
 }
 
 void DriveResourceMetadata::ClearRoot() {
   if (!root_.get())
     return;
 
-  // Note that children have a reference to root_,
-  // so we need to delete them here.
-  root_->RemoveChildren();
-  RemoveEntryFromResourceMap(root_->resource_id());
-  DCHECK(resource_map_.empty());
-  resource_map_.clear();
+  // If root resource ID is not set, it means no children.
+  if (!root_->resource_id().empty()) {

[satorux1, 2012/10/26 06:14:36]

Do we need to check? Can we just always run the same code regardless of the
resource id being empty or not?

[kochi, 2012/10/26 07:35:42]

No. RemoveEntryFromResourceMap DCHECK()'s empty resource ID.
In some unittests DriveResourceMetadata is created and destroyed without setting
the root resource ID.

In these cases when the destructor calls ClearRoot(),
root_->resource_id().empty() is true.

That said,
251 DCHECK(resource_map_.empty());
252 resource_map_.clear();
should be out of this if() and I moved out.

[satorux1, 2012/10/26 07:52:44]

I think we can change ClearRoot() to do something like

// The root is not yet initialized.
if (root_->resource_id())
  return;

+    // Note that children have a reference to root_,
+    // so we need to delete them here.
+    root_->RemoveChildren();
+    RemoveEntryFromResourceMap(root_->resource_id());
+    DCHECK(resource_map_.empty());
+    resource_map_.clear();
+  }
   root_.reset();
 }
 
 void DriveResourceMetadata::AddEntryToDirectory(
     const FilePath& directory_path,
     scoped_ptr<google_apis::DocumentEntry> doc_entry,
     const FileMoveCallback& callback) {
   DCHECK(!directory_path.empty());
   DCHECK(!callback.is_null());
 
@@ skipping 95 matching lines @@
   MoveEntryToDirectory(file_path, entry->parent()->GetFilePath(), callback);
 }
 
 void DriveResourceMetadata::RemoveEntryFromParent(
     const std::string& resource_id,
     const FileMoveCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   // Disallow deletion of root.
-  if (resource_id == kDriveRootDirectoryResourceId) {
+  if (resource_id == root_->resource_id()) {
     PostFileMoveCallbackError(callback, DRIVE_FILE_ERROR_ACCESS_DENIED);
     return;
   }
 
   DriveEntry* entry = GetEntryByResourceId(resource_id);
   if (!entry) {
     PostFileMoveCallbackError(callback, DRIVE_FILE_ERROR_NOT_FOUND);
     return;
   }
 
@@ skipping 266 matching lines @@
 }
 
 void DriveResourceMetadata::InitResourceMap(
     CreateDBParams* create_params,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(create_params);
   DCHECK(!resource_metadata_db_.get());
   DCHECK(!callback.is_null());
 
-
   SerializedMap* serialized_resources = &create_params->serialized_resources;
   resource_metadata_db_ = create_params->db.Pass();
   if (serialized_resources->empty()) {
     origin_ = INITIALIZING;
     callback.Run(DRIVE_FILE_ERROR_NOT_FOUND);
     return;
   }
 
+  // Save root directory resource ID as ClearRoot() resets |root_|.
+  std::string saved_root_resource_id = root_->resource_id();
   ClearRoot();
 
   // Version check.
   int32 version = 0;
   SerializedMap::iterator iter = serialized_resources->find(kDBKeyVersion);
   if (iter == serialized_resources->end() ||
       !base::StringToInt(iter->second, &version) ||
       version != kProtoVersion) {
     callback.Run(DRIVE_FILE_ERROR_FAILED);
     return;
@@ skipping 41 matching lines @@
         resource_map.find(entry->parent_resource_id());
     if (parent_it != resource_map.end()) {
       DriveDirectory* parent = parent_it->second->AsDriveDirectory();
       if (parent) {
         DVLOG(1) << "Adding " << entry->resource_id()
                  << " as a child of " << parent->resource_id();
         parent->AddEntry(entry);
       } else {
         NOTREACHED() << "Parent is not a directory " << parent->resource_id();
       }
-    } else if (entry->resource_id() == kDriveRootDirectoryResourceId) {
+    } else if (entry->resource_id() == saved_root_resource_id) {
       root_.reset(entry->AsDriveDirectory());
       DCHECK(root_.get());
       AddEntryToResourceMap(root_.get());
     } else {
       NOTREACHED() << "Missing parent id " << entry->parent_resource_id()
                    << " for resource " << entry->resource_id();
     }
   }
 
   if (!root_.get()) {
@@ skipping 65 matching lines @@
   if (!proto.ParseFromString(serialized_proto))
     return false;
 
   if (proto.version() != kProtoVersion) {
     LOG(ERROR) << "Incompatible proto detected (incompatible version): "
                << proto.version();
     return false;
   }
 
   root_->FromProto(proto.drive_directory());
+  // Root resource ID is already set from proto.
+  AddEntryToResourceMap(root_.get());
 
   origin_ = FROM_CACHE;
   largest_changestamp_ = proto.largest_changestamp();
 
   return true;
 }
 
 scoped_ptr<DriveEntry> DriveResourceMetadata::CreateDriveEntryFromProto(
     const DriveEntryProto& entry_proto) {
   scoped_ptr<DriveEntry> entry;
@@ skipping 61 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 drive