Replace GDataDirectory::TakeEntry with GDataDirectoryService::AddEntryToDirectory.

chrome/browser/chromeos/gdata/gdata_files_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/gdata/gdata_files.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 13 matching lines @@
 
 // See gdata.proto for the difference between the two URLs.
 const char kResumableEditMediaUrl[] = "http://resumable-edit-media/";
 const char kResumableCreateMediaUrl[] = "http://resumable-create-media/";
 
 // Add a directory to |parent| and return that directory. The name and
 // resource_id are determined by the incrementing counter |sequence_id|.
 GDataDirectory* AddDirectory(GDataDirectory* parent,
                              GDataDirectoryService* directory_service,
                              int sequence_id) {
-  GDataDirectory* dir = new GDataDirectory(parent, directory_service);
+  GDataDirectory* dir = new GDataDirectory(NULL, directory_service);
   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);
   GDataFileError error = GDATA_FILE_ERROR_FAILED;
   directory_service->AddEntryToDirectory(
       parent->GetFilePath(),
       dir,
-      base::Bind(&test_util::CopyErrorCodeFromFileOperationCallback, &error));
+      base::Bind(&test_util::CopyErrorCodeFromFilePathUpdateCallback, &error));
   test_util::RunBlockingPoolTask();
   EXPECT_EQ(GDATA_FILE_OK, error);
   return dir;
 }
 
 // Add a file to |parent| and return that file. The name and
 // resource_id are determined by the incrementing counter |sequence_id|.
 GDataFile* AddFile(GDataDirectory* parent,
                    GDataDirectoryService* directory_service,
                    int sequence_id) {
-  GDataFile* file = new GDataFile(parent, directory_service);
+  GDataFile* file = new GDataFile(NULL, directory_service);
   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);
   GDataFileError error = GDATA_FILE_ERROR_FAILED;
   directory_service->AddEntryToDirectory(
       parent->GetFilePath(),
       file,
-      base::Bind(&test_util::CopyErrorCodeFromFileOperationCallback, &error));
+      base::Bind(&test_util::CopyErrorCodeFromFilePathUpdateCallback, &error));
   test_util::RunBlockingPoolTask();
   EXPECT_EQ(GDATA_FILE_OK, error);
   return file;
 }
 
 // Creates the following files/directories
 // drive/dir1/
 // drive/dir2/
 // drive/dir1/dir3/
 // drive/dir1/file4
@@ skipping 289 matching lines @@
   // No file should be added to the root directory.
   ASSERT_TRUE(root->child_files().empty());
   // Two directories ("empty", "dir") should be added to the root directory.
   ASSERT_EQ(2U, root->child_directories().size());
   // The origin should change to FROM_CACHE because we loaded from the cache.
   ASSERT_EQ(FROM_CACHE, directory_service.origin());
 }
 
 TEST(GDataRootDirectoryTest, RefreshFile) {
   MessageLoopForUI message_loop;
+  content::TestBrowserThread ui_thread(content::BrowserThread::UI,
+                                       &message_loop);
+
   GDataDirectoryService directory_service;
-  GDataDirectory* root(directory_service.root());
   // Add a directory to the file system.
-  GDataDirectory* directory_entry = new GDataDirectory(root,
+  GDataDirectory* directory_entry = new GDataDirectory(NULL,
                                                        &directory_service);
   directory_entry->set_resource_id("folder:directory_resource_id");
   directory_entry->set_title("directory");
   directory_entry->SetBaseNameFromTitle();
   GDataFileError error = GDATA_FILE_ERROR_FAILED;
   directory_service.AddEntryToDirectory(
       FilePath(kGDataRootDirectory),
       directory_entry,
-      base::Bind(&test_util::CopyErrorCodeFromFileOperationCallback, &error));
+      base::Bind(&test_util::CopyErrorCodeFromFilePathUpdateCallback, &error));
   test_util::RunBlockingPoolTask();
   ASSERT_EQ(GDATA_FILE_OK, error);
 
   // Add a new file to the directory.
   GDataFile* initial_file_entry = new GDataFile(NULL, &directory_service);
   initial_file_entry->set_resource_id("file:file_resource_id");
   initial_file_entry->set_title("file");
   initial_file_entry->SetBaseNameFromTitle();
+  error = GDATA_FILE_ERROR_FAILED;
   directory_service.AddEntryToDirectory(
       directory_entry->GetFilePath(),
       initial_file_entry,
-      base::Bind(&test_util::CopyErrorCodeFromFileOperationCallback, &error));
+      base::Bind(&test_util::CopyErrorCodeFromFilePathUpdateCallback, &error));
   test_util::RunBlockingPoolTask();
   ASSERT_EQ(GDATA_FILE_OK, error);
 
   ASSERT_EQ(directory_entry, initial_file_entry->parent());
 
   // Initial file system state set, let's try refreshing entries.
 
   // New value for the entry with resource id "file:file_resource_id".
   GDataFile* new_file_entry = new GDataFile(NULL, &directory_service);
   new_file_entry->set_resource_id("file:file_resource_id");
@@ skipping 53 matching lines @@
   GDataDirectoryService directory_service2;
   // InitFromDB should succeed with GDATA_FILE_OK as the db now exists.
   directory_service2.InitFromDB(db_path, blocking_task_runner,
       base::Bind(&InitFromDBCallback, GDATA_FILE_OK));
   test_util::RunBlockingPoolTask();
 
   VerifyDirectoryService(&directory_service2);
 }
 
 }  // namespace gdata