drive: Use "/drive/root" namespace and fix Files app and tests.

chrome/browser/chromeos/drive/drive_resource_metadata_unittest.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 <algorithm>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/message_loop.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "chrome/browser/chromeos/drive/drive.pb.h"
 #include "chrome/browser/chromeos/drive/drive_cache.h"
+#include "chrome/browser/chromeos/drive/drive_file_system_util.h"
 #include "chrome/browser/chromeos/drive/drive_resource_metadata_storage.h"
 #include "chrome/browser/chromeos/drive/drive_test_util.h"
 #include "chrome/browser/google_apis/test_util.h"
 #include "chrome/browser/google_apis/time_util.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/test/test_browser_thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace drive {
 namespace {
 
 // See drive.proto for the difference between the two URLs.
 const char kResumableEditMediaUrl[] = "http://resumable-edit-media/";
 const char kResumableCreateMediaUrl[] = "http://resumable-create-media/";
 
-const char kTestRootResourceId[] = "test_root";
-
 // The changestamp of the resource metadata used in
 // DriveResourceMetadataTest.
 const int64 kTestChangestamp = 100;
 
 // Returns the sorted base names from |entries|.
 std::vector<std::string> GetSortedBaseNames(
     const DriveEntryProtoVector& entries) {
   std::vector<std::string> base_names;
   for (size_t i = 0; i < entries.size(); ++i)
     base_names.push_back(entries[i].base_name());
@@ skipping 36 matching lines @@
                                  const std::string& parent_resource_id);
 
   virtual void SetUp() OVERRIDE {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
 
     base::ThreadRestrictions::SetIOAllowed(false);  // For strict thread check.
     scoped_refptr<base::SequencedWorkerPool> pool =
         content::BrowserThread::GetBlockingPool();
     blocking_task_runner_ =
         pool->GetSequencedTaskRunner(pool->GetSequenceToken());
-    resource_metadata_.reset(new DriveResourceMetadata(kTestRootResourceId,
-                                                       temp_dir_.path(),
-                                                       blocking_task_runner_));
+    resource_metadata_.reset(new DriveResourceMetadata(
+        util::kDriveGrandRootSpecialResourceId,
+        temp_dir_.path(),
+        blocking_task_runner_));
     Init(resource_metadata_.get());
   }
 
   virtual void TearDown() OVERRIDE {
     resource_metadata_.reset();
     base::ThreadRestrictions::SetIOAllowed(true);
   }
 
   // Gets the entry info by path synchronously. Returns NULL on failure.
   scoped_ptr<DriveEntryProto> GetEntryInfoByPathSync(
@@ skipping 63 matching lines @@
 // static
 void DriveResourceMetadataTest::Init(DriveResourceMetadata* resource_metadata) {
   DriveFileError error = DRIVE_FILE_ERROR_FAILED;
   resource_metadata->Initialize(
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
   ASSERT_EQ(DRIVE_FILE_OK, error);
 
   int sequence_id = 1;
   ASSERT_TRUE(AddDriveEntryProto(
-      resource_metadata, sequence_id++, true, kTestRootResourceId));
+      resource_metadata, sequence_id++, true,
+      util::kDriveGrandRootSpecialResourceId));
   ASSERT_TRUE(AddDriveEntryProto(
-      resource_metadata, sequence_id++, true, kTestRootResourceId));
+      resource_metadata, sequence_id++, true,
+      util::kDriveGrandRootSpecialResourceId));
   ASSERT_TRUE(AddDriveEntryProto(
       resource_metadata, sequence_id++, true, "resource_id:dir1"));
 
   ASSERT_TRUE(AddDriveEntryProto(
       resource_metadata, sequence_id++, false, "resource_id:dir1"));
   ASSERT_TRUE(AddDriveEntryProto(
       resource_metadata, sequence_id++, false, "resource_id:dir1"));
 
   ASSERT_TRUE(AddDriveEntryProto(
       resource_metadata, sequence_id++, false, "resource_id:dir2"));
@@ skipping 60 matching lines @@
   google_apis::test_util::RunBlockingPoolTask();
   return DRIVE_FILE_OK == error;
 }
 
 TEST_F(DriveResourceMetadataTest, VersionCheck) {
   // Set up the root directory.
   DriveRootDirectoryProto proto;
   DriveEntryProto* mutable_entry =
       proto.mutable_drive_directory()->mutable_drive_entry();
   mutable_entry->mutable_file_info()->set_is_directory(true);
-  mutable_entry->set_resource_id(kTestRootResourceId);
+  mutable_entry->set_resource_id(util::kDriveGrandRootSpecialResourceId);
   mutable_entry->set_upload_url(kResumableCreateMediaUrl);
   mutable_entry->set_title("drive");
 
   scoped_ptr<DriveResourceMetadata, test_util::DestroyHelperForTests>
-      resource_metadata(new DriveResourceMetadata(kTestRootResourceId,
-                                                  temp_dir_.path(),
-                                                  blocking_task_runner_));
+      resource_metadata(new DriveResourceMetadata(
+          util::kDriveGrandRootSpecialResourceId,
+          temp_dir_.path(),
+          blocking_task_runner_));
   ForceUsingMemoryStorage(resource_metadata.get());
 
   DriveFileError error = DRIVE_FILE_ERROR_FAILED;
   resource_metadata->Initialize(
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
   ASSERT_EQ(DRIVE_FILE_OK, error);
 
   std::string serialized_proto;
   EXPECT_TRUE(proto.SerializeToString(&serialized_proto));
@@ skipping 18 matching lines @@
   // Set a newer version, and serialize.
   proto.set_version(kProtoVersion + 1);
   EXPECT_TRUE(proto.SerializeToString(&serialized_proto));
   // This should fail as the version is newer.
   EXPECT_FALSE(ParseMetadataFromString(resource_metadata.get(),
                                        serialized_proto));
 }
 
 TEST_F(DriveResourceMetadataTest, LargestChangestamp) {
   scoped_ptr<DriveResourceMetadata, test_util::DestroyHelperForTests>
-      resource_metadata(new DriveResourceMetadata(kTestRootResourceId,
-                                                  temp_dir_.path(),
-                                                  blocking_task_runner_));
+      resource_metadata(new DriveResourceMetadata(
+          util::kDriveGrandRootSpecialResourceId,
+          temp_dir_.path(),
+          blocking_task_runner_));
   DriveFileError error = DRIVE_FILE_ERROR_FAILED;
   resource_metadata->Initialize(
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
   ASSERT_EQ(DRIVE_FILE_OK, error);
 
   int64 in_changestamp = 123456;
   resource_metadata->SetLargestChangestamp(
       in_changestamp,
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_OK, error);
 
   int64 out_changestamp = 0;
   resource_metadata->GetLargestChangestamp(
       google_apis::test_util::CreateCopyResultCallback(&out_changestamp));
   google_apis::test_util::RunBlockingPoolTask();
   DCHECK_EQ(in_changestamp, out_changestamp);
 }
 
 TEST_F(DriveResourceMetadataTest, GetEntryInfoByResourceId_RootDirectory) {
   scoped_ptr<DriveResourceMetadata, test_util::DestroyHelperForTests>
-      resource_metadata(new DriveResourceMetadata(kTestRootResourceId,
-                                                  temp_dir_.path(),
-                                                  blocking_task_runner_));
+      resource_metadata(new DriveResourceMetadata(
+          util::kDriveGrandRootSpecialResourceId,
+          temp_dir_.path(),
+          blocking_task_runner_));
   DriveFileError error = DRIVE_FILE_ERROR_FAILED;
   resource_metadata->Initialize(
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
   ASSERT_EQ(DRIVE_FILE_OK, error);
 
   base::FilePath drive_file_path;
   scoped_ptr<DriveEntryProto> entry_proto;
 
   // Look up the root directory by its resource ID.
   resource_metadata->GetEntryInfoByResourceId(
-      kTestRootResourceId,
+      util::kDriveGrandRootSpecialResourceId,
       google_apis::test_util::CreateCopyResultCallback(
           &error, &drive_file_path, &entry_proto));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_OK, error);
   EXPECT_EQ(base::FilePath::FromUTF8Unsafe("drive"), drive_file_path);
   ASSERT_TRUE(entry_proto.get());
   EXPECT_EQ("drive", entry_proto->base_name());
 }
 
 TEST_F(DriveResourceMetadataTest, GetEntryInfoByResourceId) {
@@ skipping 211 matching lines @@
   // Remove unknown resource_id using RemoveEntry.
   resource_metadata_->RemoveEntry(
       "foo",
       google_apis::test_util::CreateCopyResultCallback(
           &error, &drive_file_path));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_ERROR_NOT_FOUND, error);
 
   // Try removing root. This should fail.
   resource_metadata_->RemoveEntry(
-      kTestRootResourceId,
+      util::kDriveGrandRootSpecialResourceId,
       google_apis::test_util::CreateCopyResultCallback(
           &error, &drive_file_path));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_ERROR_ACCESS_DENIED, error);
 }
 
 TEST_F(DriveResourceMetadataTest, MoveEntryToDirectory) {
   DriveFileError error = DRIVE_FILE_ERROR_FAILED;
   base::FilePath drive_file_path;
   scoped_ptr<DriveEntryProto> entry_proto;
@@ skipping 221 matching lines @@
   DriveFileError error = DRIVE_FILE_ERROR_FAILED;
   base::FilePath drive_file_path;
   scoped_ptr<DriveEntryProto> entry_proto;
 
   // Get root.
   entry_proto = GetEntryInfoByPathSync(
       base::FilePath::FromUTF8Unsafe("drive"));
   ASSERT_TRUE(entry_proto.get());
   EXPECT_EQ("drive", entry_proto->base_name());
   ASSERT_TRUE(entry_proto->file_info().is_directory());
-  EXPECT_EQ(kTestRootResourceId, entry_proto->resource_id());
+  EXPECT_EQ(util::kDriveGrandRootSpecialResourceId, entry_proto->resource_id());
   EXPECT_TRUE(entry_proto->upload_url().empty());
 
   // Set upload url and call RefreshEntry on root.
   DriveEntryProto dir_entry_proto(*entry_proto);
   dir_entry_proto.set_upload_url("http://root.upload.url/");
   entry_proto.reset();
   resource_metadata_->RefreshEntry(
       dir_entry_proto,
       google_apis::test_util::CreateCopyResultCallback(
           &error, &drive_file_path, &entry_proto));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_OK, error);
   EXPECT_EQ(base::FilePath::FromUTF8Unsafe("drive"), drive_file_path);
   ASSERT_TRUE(entry_proto.get());
   EXPECT_EQ("drive", entry_proto->base_name());
   EXPECT_TRUE(entry_proto->file_info().is_directory());
-  EXPECT_EQ(kTestRootResourceId, entry_proto->resource_id());
+  EXPECT_EQ(util::kDriveGrandRootSpecialResourceId, entry_proto->resource_id());
   EXPECT_EQ("http://root.upload.url/", entry_proto->upload_url());
 
   // Make sure the children have moved over. Test file9.
   entry_proto.reset();
   entry_proto = GetEntryInfoByPathSync(
       base::FilePath::FromUTF8Unsafe("drive/dir1/dir3/file9"));
   ASSERT_TRUE(entry_proto.get());
   EXPECT_EQ("file9", entry_proto->base_name());
 
   // Refreshing root with a proto which has parent_resource_id should fail.
@@ skipping 372 matching lines @@
   google_apis::test_util::RunBlockingPoolTask();
 
   base::FilePath drive_file_path;
   scoped_ptr<DriveEntryProto> entry_proto;
 
   // root should continue to exist.
   entry_proto = GetEntryInfoByPathSync(base::FilePath::FromUTF8Unsafe("drive"));
   ASSERT_TRUE(entry_proto.get());
   EXPECT_EQ("drive", entry_proto->base_name());
   ASSERT_TRUE(entry_proto->file_info().is_directory());
-  EXPECT_EQ(kTestRootResourceId, entry_proto->resource_id());
+  EXPECT_EQ(util::kDriveGrandRootSpecialResourceId, entry_proto->resource_id());
 
-  // root should have no children.
+  // There is only "other", which is empty.
   entries = ReadDirectoryByPathSync(base::FilePath::FromUTF8Unsafe("drive"));
   ASSERT_TRUE(entries.get());
-  EXPECT_TRUE(entries->empty());
+  EXPECT_EQ(1U, entries->size());
+
+  scoped_ptr<DriveEntryProtoVector> entries_in_other =
+      ReadDirectoryByPathSync(base::FilePath::FromUTF8Unsafe("drive/other"));
+  ASSERT_TRUE(entries_in_other.get());
+  EXPECT_TRUE(entries_in_other->empty());
+
 }
 
 TEST_F(DriveResourceMetadataTest, PerDirectoryChangestamp) {
   const int kNewChangestamp = kTestChangestamp + 1;
   const char kSubDirectoryResourceId[] = "sub-directory-id";
 
   scoped_ptr<DriveResourceMetadata, test_util::DestroyHelperForTests>
       resource_metadata_original(new DriveResourceMetadata(
-          kTestRootResourceId, temp_dir_.path(), blocking_task_runner_));
+          util::kDriveGrandRootSpecialResourceId, temp_dir_.path(),
+          blocking_task_runner_));
   ForceUsingMemoryStorage(resource_metadata_original.get());
 
   DriveFileError error = DRIVE_FILE_ERROR_FAILED;
   resource_metadata_original->Initialize(
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
   ASSERT_EQ(DRIVE_FILE_OK, error);
 
   resource_metadata_original->SetLargestChangestamp(
       kNewChangestamp,
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_OK, error);
 
   // Add a sub directory.
   DriveEntryProto directory_entry;
   directory_entry.mutable_file_info()->set_is_directory(true);
   directory_entry.set_resource_id(kSubDirectoryResourceId);
-  directory_entry.set_parent_resource_id(kTestRootResourceId);
+  directory_entry.set_parent_resource_id(
+      util::kDriveGrandRootSpecialResourceId);
   directory_entry.set_title("directory");
   base::FilePath file_path;
   resource_metadata_original->AddEntry(
       directory_entry,
       google_apis::test_util::CreateCopyResultCallback(&error, &file_path));
   // At this point, both the root and the sub directory do not contain the
   // per-directory changestamp.
   resource_metadata_original->MaybeSave();
   google_apis::test_util::RunBlockingPoolTask();
 
   scoped_ptr<DriveResourceMetadata, test_util::DestroyHelperForTests>
-      resource_metadata(new DriveResourceMetadata(kTestRootResourceId,
-                                                  temp_dir_.path(),
-                                                  blocking_task_runner_));
+      resource_metadata(new DriveResourceMetadata(
+          util::kDriveGrandRootSpecialResourceId,
+          temp_dir_.path(),
+          blocking_task_runner_));
   ForceUsingMemoryStorage(resource_metadata.get());
 
   resource_metadata->Initialize(
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
   ASSERT_EQ(DRIVE_FILE_OK, error);
 
   // Load. This should propagate the largest changestamp to every directory.
   resource_metadata->Load(
       google_apis::test_util::CreateCopyResultCallback(&error));
@@ skipping 17 matching lines @@
   google_apis::test_util::RunBlockingPoolTask();
   ASSERT_EQ(DRIVE_FILE_OK, error);
   EXPECT_EQ(kNewChangestamp,
             entry_proto->directory_specific_info().changestamp());
 }
 
 TEST_F(DriveResourceMetadataTest, SaveAndLoad) {
   // Save metadata and reset.
   resource_metadata_->MaybeSave();
 
-  resource_metadata_.reset(new DriveResourceMetadata(kTestRootResourceId,
-                                                     temp_dir_.path(),
-                                                     blocking_task_runner_));
+  resource_metadata_.reset(new DriveResourceMetadata(
+      util::kDriveGrandRootSpecialResourceId,
+      temp_dir_.path(),
+      blocking_task_runner_));
   DriveFileError error = DRIVE_FILE_ERROR_FAILED;
   resource_metadata_->Initialize(
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
   ASSERT_EQ(DRIVE_FILE_OK, error);
 
   // Load metadata.
   resource_metadata_->Load(
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_OK, error);
 
   // Try to get some data.
   scoped_ptr<DriveEntryProto> entry = GetEntryInfoByPathSync(
       base::FilePath::FromUTF8Unsafe("drive/dir1/dir3/file9"));
   ASSERT_TRUE(entry.get());
   EXPECT_EQ("file9", entry->base_name());
   ASSERT_TRUE(!entry->file_info().is_directory());
   EXPECT_EQ("md5:file9", entry->file_specific_info().file_md5());
 }
 
 }  // namespace drive