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 167 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);
 }
 
 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 13 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) {
+  DCHECK(saved_root_resource_id_.empty());
+  saved_root_resource_id_ = root_id;

[satorux1, 2012/10/23 06:54:50]

do we need this? I think we can get the same value by root_->resource_id().

[kochi, 2012/10/23 07:44:35]

This was introduced to keep the root resource ID for
InitFromDB(), as it calls ClearRoot() once to reset the
|root_| then restores |root_| from saved serialized data.
But now I realized that I can just save the ID before
ClearRoot() and use that ID in InitResourceMap().

Probably I'll have to handle offline case for Drive API,
when we can't get the root resource ID from About metadata
and has to restore metadata cache from saved DB.

   root_ = CreateDriveDirectory().Pass();
   root_->set_title(kDriveRootDirectory);
   root_->SetBaseNameFromTitle();
   root_->set_resource_id(root_id);
   AddEntryToResourceMap(root_.get());
 }
 
 void DriveResourceMetadata::ClearRoot() {
   if (!root_.get())
     return;
@@ skipping 112 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 237 matching lines @@
 }
 
 void DriveResourceMetadata::InitFromDB(
     const FilePath& db_path,
     base::SequencedTaskRunner* blocking_task_runner,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!db_path.empty());
   DCHECK(blocking_task_runner);
   DCHECK(!callback.is_null());
+  DCHECK(!saved_root_resource_id_.empty());
 
   if (resource_metadata_db_.get()) {
     callback.Run(DRIVE_FILE_ERROR_IN_USE);
     return;
   }
 
   blocking_task_runner_ = blocking_task_runner;
 
   DVLOG(1) << "InitFromDB " << db_path.value();
 
@@ skipping 10 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;
   }
 
   ClearRoot();
 
@@ skipping 48 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_) {

[satorux1, 2012/10/23 06:54:50]

why not root_->resource_id() ?

[kochi, 2012/10/23 07:44:35]

As mentioned in the previous comment.
We already called ClearRoot().

       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 41 matching lines @@
   set_last_serialized(base::Time::Now());
   set_serialized_size(serialized_size);
 
   blocking_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&ResourceMetadataDB::Save,
                  base::Unretained(resource_metadata_db_.get()),
                  serialized_resources));
 }
 
+const std::string& DriveResourceMetadata::root_resource_id() const {
+  return root_->resource_id();
+}
+
 void DriveResourceMetadata::SerializeToString(
     std::string* serialized_proto) const {
   DriveRootDirectoryProto proto;
   root_->ToProto(proto.mutable_drive_directory());
   proto.set_largest_changestamp(largest_changestamp_);
   proto.set_version(kProtoVersion);
 
   const bool ok = proto.SerializeToString(serialized_proto);
   DCHECK(ok);
 }
@@ skipping 80 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