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>
 
 #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/gdata/gdata.pb.h"
 #include "chrome/browser/chromeos/gdata/gdata_cache.h"
 #include "chrome/browser/chromeos/gdata/gdata_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 gdata {
 namespace {
 
 // See gdata.proto for the difference between the two URLs.
 const char kResumableEditMediaUrl[] = "http://resumable-edit-media/";
 const char kResumableCreateMediaUrl[] = "http://resumable-create-media/";
 
+void OnAddEntryToDirectory(GDataFileError expected_error,
+                           GDataFileError actual_error,
+                           const FilePath& updated_file_path) {
+  EXPECT_EQ(expected_error, actual_error);
+}
+
 // 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);

[satorux1, 2012/08/08 14:09:06]

can you remove the first parameter?

[achuithb, 2012/08/08 22:08:41]

In the next CL?

   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(&OnAddEntryToDirectory, GDATA_FILE_OK));

[satorux1, 2012/08/08 14:09:06]

Hmm, this looks trickier than the original code. callback is hard to follow for
me. More importantly, with the original code, it was easy to detect where the
test failed from the line number. With this new code, the line number is always
the same (line 32). This is not good.

[achuithb, 2012/08/08 22:08:41]

Good point. I can't use CopyErrorCodeFromFileOperationCallback, so I'd need to
create something like CopyErrorCodeFromFilePathUpdateCallback. Is that what
you'd prefer?

[achuithb, 2012/08/08 22:38:00]

I did this since I'm guessing you prefer this solution.

   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(&OnAddEntryToDirectory, GDATA_FILE_OK));
   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
 // drive/dir1/file5
 // drive/dir2/file6
@@ skipping 287 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(&OnAddEntryToDirectory, GDATA_FILE_OK));
   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();
   directory_service.AddEntryToDirectory(
       directory_entry->GetFilePath(),
       initial_file_entry,
-      base::Bind(&test_util::CopyErrorCodeFromFileOperationCallback, &error));
+      base::Bind(&OnAddEntryToDirectory, GDATA_FILE_OK));
   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");
   directory_service.RefreshFile(scoped_ptr<GDataFile>(new_file_entry).Pass());
   // Root should have |new_file_entry|, not |initial_file_entry|.
@@ skipping 51 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