Make DriveFeedProcessor asynchronous.

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/sequenced_task_runner.h"
 #include "base/string_number_conversions.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/message_loop.h"
 #include "chrome/browser/chromeos/drive/drive.pb.h"
 #include "chrome/browser/chromeos/drive/drive_cache.h"
-#include "chrome/browser/chromeos/drive/drive_files.h"
 #include "chrome/browser/chromeos/drive/drive_test_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/";
 
 // Callback for DriveResourceMetadata::InitFromDB.
-void InitFromDBCallback(DriveFileError expected_error,
-                        DriveFileError actual_error) {
-  EXPECT_EQ(expected_error, actual_error);
+void CopyResultsFromInitFromDBCallback(DriveFileError* expected_error,
+                                       DriveFileError actual_error) {
+  *expected_error = actual_error;
+}
+
+void OnGetChangedDirectories(std::set<FilePath>* out_changed_directories,
+                             const std::set<FilePath>& in_changed_directories) {
+  *out_changed_directories = in_changed_directories;
 }
 
 }  // namespace
 
 class DriveResourceMetadataTest : public testing::Test {
  public:
   DriveResourceMetadataTest();
 
  protected:
+  // Creates a DriveEntryProto.
+  DriveEntryProto CreateDriveEntryProto(int sequence_id,
+                                        bool is_directory,
+                                        const std::string& parent_resource_id);
+
   DriveResourceMetadata resource_metadata_;
 
  private:
   // Creates the following files/directories
   // drive/dir1/
   // drive/dir2/
   // drive/dir1/dir3/
   // drive/dir1/file4
   // drive/dir1/file5
   // drive/dir2/file6
   // drive/dir2/file7
   // drive/dir2/file8
   // drive/dir1/dir3/file9
   // drive/dir1/dir3/file10
   void Init();
 
-  // Add a directory to |parent| and return that directory. The name and
-  // resource_id are determined by the incrementing counter |sequence_id|.
-  DriveDirectory* AddDirectory(DriveDirectory* parent, int sequence_id);
-
-  // Add a file to |parent| and return that file. The name and
-  // resource_id are determined by the incrementing counter |sequence_id|.
-  DriveFile* AddFile(DriveDirectory* parent, int sequence_id);
+  // Add a DriveEntryProto to the metadata tree.
+  void AddDriveEntryProto(int sequence_id,
+                          bool is_directory,
+                          const std::string& parent_resource_id);
 
   MessageLoopForUI message_loop_;
   content::TestBrowserThread ui_thread_;
 };
 
 DriveResourceMetadataTest::DriveResourceMetadataTest()
     : ui_thread_(content::BrowserThread::UI, &message_loop_) {
   Init();
 }
 
 void DriveResourceMetadataTest::Init() {
   resource_metadata_.InitializeRootEntry(kWAPIRootDirectoryResourceId);
 
   int sequence_id = 1;
-  DriveDirectory* dir1 = AddDirectory(resource_metadata_.root(), sequence_id++);
-  DriveDirectory* dir2 = AddDirectory(resource_metadata_.root(), sequence_id++);
-  DriveDirectory* dir3 = AddDirectory(dir1, sequence_id++);
+  AddDriveEntryProto(sequence_id++, true, kWAPIRootDirectoryResourceId);
+  AddDriveEntryProto(sequence_id++, true, kWAPIRootDirectoryResourceId);
+  AddDriveEntryProto(sequence_id++, true, "resource_id:dir1");
 
-  AddFile(dir1, sequence_id++);
-  AddFile(dir1, sequence_id++);
+  AddDriveEntryProto(sequence_id++, false, "resource_id:dir1");
+  AddDriveEntryProto(sequence_id++, false, "resource_id:dir1");
 
-  AddFile(dir2, sequence_id++);
-  AddFile(dir2, sequence_id++);
-  AddFile(dir2, sequence_id++);
+  AddDriveEntryProto(sequence_id++, false, "resource_id:dir2");
+  AddDriveEntryProto(sequence_id++, false, "resource_id:dir2");
+  AddDriveEntryProto(sequence_id++, false, "resource_id:dir2");
 
-  AddFile(dir3, sequence_id++);
-  AddFile(dir3, sequence_id++);
+  AddDriveEntryProto(sequence_id++, false, "resource_id:dir3");
+  AddDriveEntryProto(sequence_id++, false, "resource_id:dir3");
 }
 
-DriveDirectory* DriveResourceMetadataTest::AddDirectory(DriveDirectory* parent,
-                                                        int sequence_id) {
-  scoped_ptr<DriveDirectory> dir = resource_metadata_.CreateDriveDirectory();
-  const std::string dir_name = "dir" + base::IntToString(sequence_id);
-  const std::string resource_id = std::string("dir_resource_id:") + dir_name;
-  dir->set_title(dir_name);
-  dir->set_resource_id(resource_id);
+DriveEntryProto DriveResourceMetadataTest::CreateDriveEntryProto(
+    int sequence_id,
+    bool is_directory,
+    const std::string& parent_resource_id) {
+  DriveEntryProto entry_proto;
+  const std::string sequence_id_str = base::IntToString(sequence_id);
+  const std::string title = (is_directory ? "dir" : "file") +
+                                sequence_id_str;
+  const std::string resource_id = "resource_id:" + title;
+  entry_proto.set_title(title);
+  entry_proto.set_resource_id(resource_id);
+  entry_proto.set_parent_resource_id(parent_resource_id);
 
-  parent->AddEntry(dir.get());
+  PlatformFileInfoProto* file_info = entry_proto.mutable_file_info();
+  file_info->set_is_directory(is_directory);
 
-  return dir.release();
+  if (!is_directory) {
+    DriveFileSpecificInfo* file_specific_info =
+        entry_proto.mutable_file_specific_info();
+    file_info->set_size(sequence_id * 1024);
+    file_specific_info->set_file_md5(std::string("md5:") + title);
+  }
+  return entry_proto;
 }
 
-DriveFile* DriveResourceMetadataTest::AddFile(DriveDirectory* parent,
-                                              int sequence_id) {
-  scoped_ptr<DriveFile> file = resource_metadata_.CreateDriveFile();
-  const std::string title = "file" + base::IntToString(sequence_id);
-  const std::string resource_id = std::string("file_resource_id:") + title;
-  file->set_title(title);
-  file->set_resource_id(resource_id);
-  file->set_file_md5(std::string("file_md5:") + title);
+void DriveResourceMetadataTest::AddDriveEntryProto(
+    int sequence_id,
+    bool is_directory,
+    const std::string& parent_resource_id) {
+  DriveEntryProto entry_proto = CreateDriveEntryProto(sequence_id,
+                                                      is_directory,
+                                                      parent_resource_id);
+  DriveFileError error = DRIVE_FILE_ERROR_FAILED;
+  FilePath drive_file_path;
 
-  parent->AddEntry(file.get());
-
-  return file.release();
+  resource_metadata_.AddEntryToParent(
+      entry_proto,
+      base::Bind(&test_util::CopyResultsFromFileMoveCallback,
+                 &error, &drive_file_path));
+  google_apis::test_util::RunBlockingPoolTask();
+  ASSERT_EQ(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(kWAPIRootDirectoryResourceId);
   mutable_entry->set_upload_url(kResumableCreateMediaUrl);
@@ skipping 20 matching lines @@
 
   // Set a newer version, and serialize.
   proto.set_version(kProtoVersion + 1);
   ASSERT_TRUE(proto.SerializeToString(&serialized_proto));
   // This should fail as the version is newer.
   ASSERT_FALSE(resource_metadata.ParseFromString(serialized_proto));
 }
 
 TEST_F(DriveResourceMetadataTest, GetEntryByResourceId_RootDirectory) {
   DriveResourceMetadata resource_metadata;
+
+  DriveFileError error = DRIVE_FILE_ERROR_FAILED;
+  FilePath drive_file_path;
+  scoped_ptr<DriveEntryProto> entry_proto;
+
   // Look up the root directory by its resource ID.
-  DriveEntry* entry = resource_metadata.GetEntryByResourceId(
-      kWAPIRootDirectoryResourceId);
-  ASSERT_FALSE(entry);
+  resource_metadata.GetEntryInfoByResourceId(
+      kWAPIRootDirectoryResourceId,
+      base::Bind(&test_util::CopyResultsFromGetEntryInfoWithFilePathCallback,
+                 &error, &drive_file_path, &entry_proto));
+  google_apis::test_util::RunBlockingPoolTask();
+  ASSERT_EQ(DRIVE_FILE_ERROR_NOT_FOUND, error);
+
   // Initialize root and look it up again.
   resource_metadata.InitializeRootEntry(kWAPIRootDirectoryResourceId);
-  entry = resource_metadata.GetEntryByResourceId(
-      kWAPIRootDirectoryResourceId);
-  ASSERT_TRUE(entry);
 
-  EXPECT_EQ(kWAPIRootDirectoryResourceId, entry->resource_id());
+  resource_metadata.GetEntryInfoByResourceId(
+      kWAPIRootDirectoryResourceId,
+      base::Bind(&test_util::CopyResultsFromGetEntryInfoWithFilePathCallback,
+                 &error, &drive_file_path, &entry_proto));
+  google_apis::test_util::RunBlockingPoolTask();
+  EXPECT_EQ(DRIVE_FILE_OK, error);
+  ASSERT_TRUE(entry_proto.get());
+  EXPECT_EQ(kWAPIRootDirectoryResourceId, entry_proto->resource_id());
+  EXPECT_EQ(FilePath::FromUTF8Unsafe("drive"), drive_file_path);
 }
 
 TEST_F(DriveResourceMetadataTest, GetEntryInfoByResourceId) {
   // Confirm that an existing file is found.
   DriveFileError error = DRIVE_FILE_ERROR_FAILED;
   FilePath drive_file_path;
   scoped_ptr<DriveEntryProto> entry_proto;
   resource_metadata_.GetEntryInfoByResourceId(
-      "file_resource_id:file4",
+      "resource_id:file4",
       base::Bind(&test_util::CopyResultsFromGetEntryInfoWithFilePathCallback,
                  &error, &drive_file_path, &entry_proto));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_OK, error);
   EXPECT_EQ(FilePath::FromUTF8Unsafe("drive/dir1/file4"), drive_file_path);
   ASSERT_TRUE(entry_proto.get());
   EXPECT_EQ("file4", entry_proto->base_name());
 
   // Confirm that a non existing file is not found.
   error = DRIVE_FILE_ERROR_FAILED;
@@ skipping 143 matching lines @@
   TestingProfile profile;
   scoped_refptr<base::SequencedWorkerPool> pool =
       content::BrowserThread::GetBlockingPool();
   scoped_refptr<base::SequencedTaskRunner> blocking_task_runner =
       pool->GetSequencedTaskRunner(pool->GetSequenceToken());
 
   FilePath db_path(DriveCache::GetCacheRootPath(&profile).
       AppendASCII("meta").AppendASCII("resource_metadata.db"));
   // InitFromDB should fail with DRIVE_FILE_ERROR_NOT_FOUND since the db
   // doesn't exist.
-  resource_metadata_.InitFromDB(db_path, blocking_task_runner,
-      base::Bind(&InitFromDBCallback, DRIVE_FILE_ERROR_NOT_FOUND));
+  DriveFileError db_error;
+  resource_metadata_.InitFromDB(
+      db_path,
+      blocking_task_runner,
+      base::Bind(&CopyResultsFromInitFromDBCallback, &db_error));
   google_apis::test_util::RunBlockingPoolTask();
+  EXPECT_EQ(DRIVE_FILE_ERROR_NOT_FOUND, db_error);
 
   // Create a file system and write it to disk.
   // We cannot call SaveToDB without first having called InitFromDB because
   // InitFrom initializes the db_path and blocking_task_runner needed by
   // SaveToDB.
   resource_metadata_.SaveToDB();
   google_apis::test_util::RunBlockingPoolTask();
 
   // InitFromDB should fail with DRIVE_FILE_ERROR_IN_USE.
-  resource_metadata_.InitFromDB(db_path, blocking_task_runner,
-      base::Bind(&InitFromDBCallback, DRIVE_FILE_ERROR_IN_USE));
+  resource_metadata_.InitFromDB(
+      db_path,
+      blocking_task_runner,
+      base::Bind(&CopyResultsFromInitFromDBCallback, &db_error));
   google_apis::test_util::RunBlockingPoolTask();
+  EXPECT_EQ(DRIVE_FILE_ERROR_IN_USE, db_error);
 
   // InitFromDB should succeed.
   DriveResourceMetadata test_resource_metadata;
   test_resource_metadata.InitializeRootEntry(kWAPIRootDirectoryResourceId);
-  test_resource_metadata.InitFromDB(db_path, blocking_task_runner,
-      base::Bind(&InitFromDBCallback, DRIVE_FILE_OK));
+  test_resource_metadata.InitFromDB(
+      db_path,
+      blocking_task_runner,
+      base::Bind(&CopyResultsFromInitFromDBCallback, &db_error));
   google_apis::test_util::RunBlockingPoolTask();
+  EXPECT_EQ(DRIVE_FILE_OK, db_error);
 
   // Verify by checking for drive/dir2, which should have 3 children.
   DriveFileError error = DRIVE_FILE_ERROR_FAILED;
   scoped_ptr<DriveEntryProtoVector> entries;
   test_resource_metadata.ReadDirectoryByPath(
       FilePath::FromUTF8Unsafe("drive/dir2"),
       base::Bind(&test_util::CopyResultsFromReadDirectoryCallback,
                  &error, &entries));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_OK, error);
   ASSERT_TRUE(entries.get());
   ASSERT_EQ(3U, entries->size());
 }
 
 TEST_F(DriveResourceMetadataTest, RemoveEntryFromParent) {
   // Make sure file9 is found.
   DriveFileError error = DRIVE_FILE_ERROR_FAILED;
   FilePath drive_file_path;
-  const std::string file9_resource_id = "file_resource_id:file9";
+  const std::string file9_resource_id = "resource_id:file9";
   scoped_ptr<DriveEntryProto> entry_proto;
   resource_metadata_.GetEntryInfoByResourceId(
       file9_resource_id,
       base::Bind(&test_util::CopyResultsFromGetEntryInfoWithFilePathCallback,
                  &error, &drive_file_path, &entry_proto));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_OK, error);
   EXPECT_EQ(FilePath::FromUTF8Unsafe("drive/dir1/dir3/file9"), drive_file_path);
   ASSERT_TRUE(entry_proto.get());
   EXPECT_EQ("file9", entry_proto->base_name());
@@ skipping 10 matching lines @@
   // file9 should no longer exist.
   resource_metadata_.GetEntryInfoByResourceId(
       file9_resource_id,
       base::Bind(&test_util::CopyResultsFromGetEntryInfoWithFilePathCallback,
                  &error, &drive_file_path, &entry_proto));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_ERROR_NOT_FOUND, error);
   EXPECT_FALSE(entry_proto.get());
 
   // Look for dir3.
-  const std::string dir3_resource_id = "dir_resource_id:dir3";
+  const std::string dir3_resource_id = "resource_id:dir3";
   resource_metadata_.GetEntryInfoByResourceId(
       dir3_resource_id,
       base::Bind(&test_util::CopyResultsFromGetEntryInfoWithFilePathCallback,
                  &error, &drive_file_path, &entry_proto));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_OK, error);
   EXPECT_EQ(FilePath::FromUTF8Unsafe("drive/dir1/dir3"), drive_file_path);
   ASSERT_TRUE(entry_proto.get());
   EXPECT_EQ("dir3", entry_proto->base_name());
 
@@ skipping 18 matching lines @@
   // Remove unknown resource_id using RemoveEntryFromParent.
   resource_metadata_.RemoveEntryFromParent(
       "foo",
       base::Bind(&test_util::CopyResultsFromFileMoveCallback,
           &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_.RemoveEntryFromParent(
-      resource_metadata_.root()->resource_id(),
+      kWAPIRootDirectoryResourceId,
       base::Bind(&test_util::CopyResultsFromFileMoveCallback,
           &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;
   FilePath drive_file_path;
   scoped_ptr<DriveEntryProto> entry_proto;
 
   // Move file8 to drive/dir1.
   resource_metadata_.MoveEntryToDirectory(
       FilePath::FromUTF8Unsafe("drive/dir2/file8"),
       FilePath::FromUTF8Unsafe("drive/dir1"),
       base::Bind(&test_util::CopyResultsFromFileMoveCallback,
                  &error, &drive_file_path));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_OK, error);
   EXPECT_EQ(FilePath::FromUTF8Unsafe("drive/dir1/file8"), drive_file_path);
 
   // Look up the entry by its resource id and make sure it really moved.
   resource_metadata_.GetEntryInfoByResourceId(
-      "file_resource_id:file8",
+      "resource_id:file8",
       base::Bind(&test_util::CopyResultsFromGetEntryInfoWithFilePathCallback,
                  &error, &drive_file_path, &entry_proto));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_OK, error);
   EXPECT_EQ(FilePath::FromUTF8Unsafe("drive/dir1/file8"), drive_file_path);
 
   // Move non-existent file to drive/dir1. This should fail.
   resource_metadata_.MoveEntryToDirectory(
       FilePath::FromUTF8Unsafe("drive/dir2/file8"),
       FilePath::FromUTF8Unsafe("drive/dir1"),
@@ skipping 38 matching lines @@
       FilePath::FromUTF8Unsafe("drive/file8"),
       FilePath::FromUTF8Unsafe("drive/dir2"),
       base::Bind(&test_util::CopyResultsFromFileMoveCallback,
                  &error, &drive_file_path));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_OK, error);
   EXPECT_EQ(FilePath::FromUTF8Unsafe("drive/dir2/file8"), drive_file_path);
 
   // Make sure file is still ok.
   resource_metadata_.GetEntryInfoByResourceId(
-      "file_resource_id:file8",
+      "resource_id:file8",
       base::Bind(&test_util::CopyResultsFromGetEntryInfoWithFilePathCallback,
                  &error, &drive_file_path, &entry_proto));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_OK, error);
   EXPECT_EQ(FilePath::FromUTF8Unsafe("drive/dir2/file8"), drive_file_path);
 }
 
 TEST_F(DriveResourceMetadataTest, RenameEntry) {
   DriveFileError error = DRIVE_FILE_ERROR_FAILED;
   FilePath drive_file_path;
   scoped_ptr<DriveEntryProto> entry_proto;
 
   // Rename file8 to file11.
   resource_metadata_.RenameEntry(
       FilePath::FromUTF8Unsafe("drive/dir2/file8"),
       "file11",
       base::Bind(&test_util::CopyResultsFromFileMoveCallback,
                  &error, &drive_file_path));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_OK, error);
   EXPECT_EQ(FilePath::FromUTF8Unsafe("drive/dir2/file11"), drive_file_path);
 
   // Lookup the file by resource id to make sure the file actually got renamed.
   resource_metadata_.GetEntryInfoByResourceId(
-      "file_resource_id:file8",
+      "resource_id:file8",
       base::Bind(&test_util::CopyResultsFromGetEntryInfoWithFilePathCallback,
                  &error, &drive_file_path, &entry_proto));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_OK, error);
   EXPECT_EQ(FilePath::FromUTF8Unsafe("drive/dir2/file11"), drive_file_path);
 
   // Rename to file7 to force a duplicate name.
   resource_metadata_.RenameEntry(
       FilePath::FromUTF8Unsafe("drive/dir2/file11"),
       "file7",
@@ skipping 17 matching lines @@
   resource_metadata_.RenameEntry(
       FilePath::FromUTF8Unsafe("drive/dir2/file11"),
       "file11",
       base::Bind(&test_util::CopyResultsFromFileMoveCallback,
                  &error, &drive_file_path));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_ERROR_NOT_FOUND, error);
   EXPECT_EQ(FilePath(), drive_file_path);
 }
 
+TEST_F(DriveResourceMetadataTest, RefreshEntryProto) {
+  DriveFileError error = DRIVE_FILE_ERROR_FAILED;
+  FilePath drive_file_path;
+  scoped_ptr<DriveEntryProto> entry_proto;
+
+  // Get file9.
+  resource_metadata_.GetEntryInfoByPath(
+      FilePath::FromUTF8Unsafe("drive/dir1/dir3/file9"),
+      base::Bind(&test_util::CopyResultsFromGetEntryInfoCallback,
+                 &error, &entry_proto));
+  google_apis::test_util::RunBlockingPoolTask();
+  EXPECT_EQ(DRIVE_FILE_OK, error);
+  ASSERT_TRUE(entry_proto.get());
+  EXPECT_EQ("file9", entry_proto->base_name());
+  ASSERT_TRUE(entry_proto->has_file_specific_info());
+  EXPECT_EQ("md5:file9", entry_proto->file_specific_info().file_md5());
+
+  // Rename it and change the file size.
+  DriveEntryProto file_entry_proto(*entry_proto);
+  const std::string updated_md5("md5:updated");
+  file_entry_proto.mutable_file_specific_info()->set_file_md5(updated_md5);
+  file_entry_proto.set_title("file100");
+  entry_proto.reset();
+  resource_metadata_.RefreshEntryProto(
+      file_entry_proto,
+      base::Bind(&test_util::CopyResultsFromGetEntryInfoWithFilePathCallback,
+                 &error, &drive_file_path, &entry_proto));
+  google_apis::test_util::RunBlockingPoolTask();
+  EXPECT_EQ(DRIVE_FILE_OK, error);
+  EXPECT_EQ(FilePath::FromUTF8Unsafe("drive/dir1/dir3/file100"),
+            drive_file_path);
+  ASSERT_TRUE(entry_proto.get());
+  EXPECT_EQ("file100", entry_proto->base_name());
+  ASSERT_TRUE(entry_proto->has_file_specific_info());
+  EXPECT_EQ(updated_md5, entry_proto->file_specific_info().file_md5());
+
+  // Make sure we get the same thing from GetEntryInfoByPath.
+  entry_proto.reset();
+  resource_metadata_.GetEntryInfoByPath(
+      FilePath::FromUTF8Unsafe("drive/dir1/dir3/file100"),
+      base::Bind(&test_util::CopyResultsFromGetEntryInfoCallback,
+                 &error, &entry_proto));
+  google_apis::test_util::RunBlockingPoolTask();
+  EXPECT_EQ(DRIVE_FILE_OK, error);
+  ASSERT_TRUE(entry_proto.get());
+  EXPECT_EQ("file100", entry_proto->base_name());
+  ASSERT_TRUE(entry_proto->has_file_specific_info());
+  EXPECT_EQ(updated_md5, entry_proto->file_specific_info().file_md5());
+
+  // Get dir2.
+  entry_proto.reset();
+  resource_metadata_.GetEntryInfoByPath(
+      FilePath::FromUTF8Unsafe("drive/dir2"),
+      base::Bind(&test_util::CopyResultsFromGetEntryInfoCallback,
+                 &error, &entry_proto));
+  google_apis::test_util::RunBlockingPoolTask();
+  EXPECT_EQ(DRIVE_FILE_OK, error);
+  ASSERT_TRUE(entry_proto.get());
+  EXPECT_EQ("dir2", entry_proto->base_name());
+  ASSERT_TRUE(entry_proto->file_info().is_directory());
+
+  // Change the name to dir100 and change the parent to drive/dir1/dir3.
+  DriveEntryProto dir_entry_proto(*entry_proto);
+  dir_entry_proto.set_title("dir100");
+  dir_entry_proto.set_parent_resource_id("resource_id:dir3");
+  entry_proto.reset();
+  resource_metadata_.RefreshEntryProto(
+      dir_entry_proto,
+      base::Bind(&test_util::CopyResultsFromGetEntryInfoWithFilePathCallback,
+                 &error, &drive_file_path, &entry_proto));
+  google_apis::test_util::RunBlockingPoolTask();
+  EXPECT_EQ(DRIVE_FILE_OK, error);
+  EXPECT_EQ(FilePath::FromUTF8Unsafe("drive/dir1/dir3/dir100"),
+            drive_file_path);
+  ASSERT_TRUE(entry_proto.get());
+  EXPECT_EQ("dir100", entry_proto->base_name());
+  EXPECT_TRUE(entry_proto->file_info().is_directory());
+  EXPECT_EQ("resource_id:dir2", entry_proto->resource_id());
+
+  // Make sure the children have moved over. Test file6.
+  entry_proto.reset();
+  resource_metadata_.GetEntryInfoByPath(
+      FilePath::FromUTF8Unsafe("drive/dir1/dir3/dir100/file6"),
+      base::Bind(&test_util::CopyResultsFromGetEntryInfoCallback,
+                 &error, &entry_proto));
+  google_apis::test_util::RunBlockingPoolTask();
+  EXPECT_EQ(DRIVE_FILE_OK, error);
+  ASSERT_TRUE(entry_proto.get());
+  EXPECT_EQ("file6", entry_proto->base_name());
+
+  // Make sure dir2 no longer exists.
+  resource_metadata_.GetEntryInfoByPath(
+      FilePath::FromUTF8Unsafe("drive/dir2"),
+      base::Bind(&test_util::CopyResultsFromGetEntryInfoCallback,
+                 &error, &entry_proto));
+  google_apis::test_util::RunBlockingPoolTask();
+  EXPECT_EQ(DRIVE_FILE_ERROR_NOT_FOUND, error);
+  EXPECT_FALSE(entry_proto.get());
+}
+
+TEST_F(DriveResourceMetadataTest, AddEntryToParent) {
+  int sequence_id = 100;
+  DriveEntryProto file_entry_proto = CreateDriveEntryProto(
+      sequence_id++, false, "resource_id:dir3");
+
+  DriveFileError error = DRIVE_FILE_ERROR_FAILED;
+  FilePath drive_file_path;
+
+  // Add to dir3.
+  resource_metadata_.AddEntryToParent(
+      file_entry_proto,
+      base::Bind(&test_util::CopyResultsFromFileMoveCallback,
+                 &error, &drive_file_path));
+  google_apis::test_util::RunBlockingPoolTask();
+  EXPECT_EQ(DRIVE_FILE_OK, error);
+  EXPECT_EQ(FilePath::FromUTF8Unsafe("drive/dir1/dir3/file100"),
+            drive_file_path);
+
+  // Adds to root when parent resource id is not specified.
+  DriveEntryProto file_entry_proto2 = CreateDriveEntryProto(
+      sequence_id++, false, "");
+
+  resource_metadata_.AddEntryToParent(
+      file_entry_proto2,
+      base::Bind(&test_util::CopyResultsFromFileMoveCallback,
+                 &error, &drive_file_path));
+  google_apis::test_util::RunBlockingPoolTask();
+  EXPECT_EQ(DRIVE_FILE_OK, error);
+  EXPECT_EQ(FilePath::FromUTF8Unsafe("drive/file101"), drive_file_path);
+
+  // Add a directory.
+  DriveEntryProto dir_entry_proto = CreateDriveEntryProto(
+      sequence_id++, true, "resource_id:dir1");
+
+  resource_metadata_.AddEntryToParent(
+      dir_entry_proto,
+      base::Bind(&test_util::CopyResultsFromFileMoveCallback,
+                 &error, &drive_file_path));
+  google_apis::test_util::RunBlockingPoolTask();
+  EXPECT_EQ(DRIVE_FILE_OK, error);
+  EXPECT_EQ(FilePath::FromUTF8Unsafe("drive/dir1/dir102"), drive_file_path);
+
+  // Add to an invalid parent.
+  DriveEntryProto file_entry_proto3 = CreateDriveEntryProto(
+      sequence_id++, false, "resource_id:invalid");
+
+  resource_metadata_.AddEntryToParent(
+      file_entry_proto3,
+      base::Bind(&test_util::CopyResultsFromFileMoveCallback,
+                 &error, &drive_file_path));
+  google_apis::test_util::RunBlockingPoolTask();
+  EXPECT_EQ(DRIVE_FILE_ERROR_NOT_FOUND, error);
+}
+
+TEST_F(DriveResourceMetadataTest, GetChangedDirectories) {
+  std::set<FilePath> changed_directories;
+
+  // file9: only drive/dir1/dir3 is affected.
+  resource_metadata_.GetChangedDirectories("resource_id:file9",
+      base::Bind(&OnGetChangedDirectories, &changed_directories));
+  google_apis::test_util::RunBlockingPoolTask();
+  EXPECT_EQ(1u, changed_directories.size());
+  EXPECT_EQ(1u, changed_directories.count(
+      FilePath::FromUTF8Unsafe("drive/dir1/dir3")));
+
+  // dir2: root and dir2 are affected.
+  resource_metadata_.GetChangedDirectories("resource_id:dir2",
+      base::Bind(&OnGetChangedDirectories, &changed_directories));
+  google_apis::test_util::RunBlockingPoolTask();
+  EXPECT_EQ(2u, changed_directories.size());
+  EXPECT_EQ(1u, changed_directories.count(
+      FilePath::FromUTF8Unsafe("drive")));
+  EXPECT_EQ(1u, changed_directories.count(
+      FilePath::FromUTF8Unsafe("drive/dir2")));
+
+  // dir1: root, dir1, and dir3 are affected.
+  resource_metadata_.GetChangedDirectories("resource_id:dir1",
+      base::Bind(&OnGetChangedDirectories, &changed_directories));
+  google_apis::test_util::RunBlockingPoolTask();
+  EXPECT_EQ(3u, changed_directories.size());
+  EXPECT_EQ(1u, changed_directories.count(
+      FilePath::FromUTF8Unsafe("drive")));
+  EXPECT_EQ(1u, changed_directories.count(
+      FilePath::FromUTF8Unsafe("drive/dir1")));
+  EXPECT_EQ(1u, changed_directories.count(
+      FilePath::FromUTF8Unsafe("drive/dir1/dir3")));
+}
+
 TEST_F(DriveResourceMetadataTest, TakeOverEntries) {
   DriveFileError error = DRIVE_FILE_ERROR_FAILED;
   FilePath drive_file_path;
   scoped_ptr<DriveEntryProto> entry_proto;
 
   // Move files from dir1 to dir2.
   resource_metadata_.TakeOverEntries(
-      "dir_resource_id:dir1",
-      "dir_resource_id:dir2",
+      "resource_id:dir1",
+      "resource_id:dir2",
       base::Bind(&test_util::CopyResultsFromFileMoveCallback,
                  &error, &drive_file_path));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_OK, error);
   EXPECT_EQ(FilePath::FromUTF8Unsafe("drive/dir2"), drive_file_path);
 
   // Check if the file move worked. file6 should now be in drive/dir2.
   resource_metadata_.GetEntryInfoByPath(
       FilePath::FromUTF8Unsafe("drive/dir2/file6"),
       base::Bind(&test_util::CopyResultsFromGetEntryInfoCallback,
@@ skipping 29 matching lines @@
       FilePath::FromUTF8Unsafe("drive/dir2"),
       base::Bind(&test_util::CopyResultsFromReadDirectoryCallback,
                  &error, &entries));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_OK, error);
   ASSERT_TRUE(entries.get());
   ASSERT_EQ(6U, entries->size());
 }
 
 }  // namespace drive