ResourceId and unit test cleanup.

chrome/browser/chromeos/gdata/gdata_directory_service_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_directory_service.h"
 
 #include <algorithm>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 172 matching lines @@
   EXPECT_EQ(file10, directory_service->GetEntryByResourceId(
       "file_resource_id:file10"));
 }
 
 // Callback for GDataDirectoryService::InitFromDB.
 void InitFromDBCallback(GDataFileError expected_error,
                         GDataFileError actual_error) {
   EXPECT_EQ(expected_error, actual_error);
 }
 
+// Callback for GDataDirectoryService::ReadDirectoryByPath.
+void ReadDirectoryByPathCallback(
+    scoped_ptr<GDataEntryProtoVector>* result,
+    GDataFileError error,
+    scoped_ptr<GDataEntryProtoVector> entries) {
+  EXPECT_EQ(GDATA_FILE_OK, error);
+  *result = entries.Pass();
+}
+
 }  // namespace
 
 TEST(GDataDirectoryServiceTest, VersionCheck) {
   // Set up the root directory.
   GDataRootDirectoryProto proto;
   GDataEntryProto* mutable_entry =
       proto.mutable_gdata_directory()->mutable_gdata_entry();
   mutable_entry->mutable_file_info()->set_is_directory(true);
   mutable_entry->set_resource_id(kGDataRootDirectoryResourceId);
   mutable_entry->set_upload_url(kResumableCreateMediaUrl);
@@ skipping 89 matching lines @@
 
   // This should succeed as the resource ID is correct.
   ASSERT_TRUE(directory_service.ParseFromString(serialized_proto));
   EXPECT_EQ(kGDataRootDirectoryResourceId, root->resource_id());
 }
 
 // We have a similar test in FromProto_DetectBadUploadUrl, but the test here
 // is to ensure that an error in GDataFile::FromProto() is properly
 // propagated to GDataRootDirectory::ParseFromString().
 TEST(GDataDirectoryServiceTest, ParseFromString_DetectNoUploadUrl) {
+  // Need to run on UI thread to call
+  // GDataDirectoryService::ReadDirectoryByPath.
+  MessageLoopForUI message_loop;
+  content::TestBrowserThread ui_thread(content::BrowserThread::UI,
+                                       &message_loop);
+
   // Set up the root directory properly.
   GDataRootDirectoryProto root_directory_proto;
   root_directory_proto.set_version(kProtoVersion);
 
   GDataEntryProto* mutable_entry =
       root_directory_proto.mutable_gdata_directory()->mutable_gdata_entry();
   mutable_entry->mutable_file_info()->set_is_directory(true);
   mutable_entry->set_title(kGDataRootDirectory);
   mutable_entry->set_resource_id(kGDataRootDirectoryResourceId);
   mutable_entry->set_upload_url(kResumableCreateMediaUrl);
 
   // Add an empty sub directory under the root directory. This directory is
   // added to ensure that nothing is left when the parsing failed.
   GDataDirectoryProto* sub_directory_proto =
       root_directory_proto.mutable_gdata_directory()->add_child_directories();
   sub_directory_proto->mutable_gdata_entry()->mutable_file_info()->
       set_is_directory(true);
   sub_directory_proto->mutable_gdata_entry()->set_title("empty");
+  sub_directory_proto->mutable_gdata_entry()->set_resource_id("res:empty");
   sub_directory_proto->mutable_gdata_entry()->set_upload_url(
       kResumableCreateMediaUrl);
 
   // Add a sub directory under the root directory.
   sub_directory_proto =
       root_directory_proto.mutable_gdata_directory()->add_child_directories();
   sub_directory_proto->mutable_gdata_entry()->mutable_file_info()->
       set_is_directory(true);
   sub_directory_proto->mutable_gdata_entry()->set_title("dir");
+  sub_directory_proto->mutable_gdata_entry()->set_resource_id("res:dir");
   sub_directory_proto->mutable_gdata_entry()->set_upload_url(
       kResumableCreateMediaUrl);
 
   // Add a new file under the sub directory "dir".
   GDataEntryProto* entry_proto =
       sub_directory_proto->add_child_files();
   entry_proto->set_title("test.txt");
+  entry_proto->set_resource_id("res:file");
   entry_proto->mutable_file_specific_info()->set_file_md5("md5");
 
   GDataDirectoryService directory_service;
-  GDataDirectory* root(directory_service.root());
   // The origin is set to UNINITIALIZED by default.
   ASSERT_EQ(UNINITIALIZED, directory_service.origin());
   std::string serialized_proto;
   // Serialize the proto and check if it's loaded.
   // This should fail as the upload URL is not set for |entry_proto|.
   ASSERT_TRUE(root_directory_proto.SerializeToString(&serialized_proto));
   ASSERT_FALSE(directory_service.ParseFromString(serialized_proto));
+
   // Nothing should be added to the root directory if the parse failed.
-  ASSERT_TRUE(root->child_files().empty());
-  ASSERT_TRUE(root->child_directories().empty());
+  scoped_ptr<GDataEntryProtoVector> result;
+  directory_service.ReadDirectoryByPath(FilePath(kGDataRootDirectory),
+      base::Bind(&ReadDirectoryByPathCallback, &result));
+  test_util::RunBlockingPoolTask();
+  EXPECT_TRUE(result->empty());
+
   // The origin should remain UNINITIALIZED because the loading failed.
   ASSERT_EQ(UNINITIALIZED, directory_service.origin());
 
   // Set an upload URL.
   entry_proto->set_upload_url(kResumableEditMediaUrl);
 
   // Serialize the proto and check if it's loaded.
   // This should succeed as the upload URL is set for |entry_proto|.
   ASSERT_TRUE(root_directory_proto.SerializeToString(&serialized_proto));
   ASSERT_TRUE(directory_service.ParseFromString(serialized_proto));
-  // No file should be added to the root directory.
-  ASSERT_TRUE(root->child_files().empty());
+  directory_service.ReadDirectoryByPath(FilePath(kGDataRootDirectory),
+      base::Bind(&ReadDirectoryByPathCallback, &result));
+  test_util::RunBlockingPoolTask();
   // Two directories ("empty", "dir") should be added to the root directory.
-  ASSERT_EQ(2U, root->child_directories().size());
+  EXPECT_EQ(2U, result->size());
   // The origin should change to FROM_CACHE because we loaded from the cache.
   ASSERT_EQ(FROM_CACHE, directory_service.origin());
 }
 
 TEST(GDataDirectoryServiceTest, RefreshFile) {
   MessageLoopForUI message_loop;
   content::TestBrowserThread ui_thread(content::BrowserThread::UI,
                                        &message_loop);
 
   GDataDirectoryService directory_service;
@@ skipping 247 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