Rename GData* to Drive* in gdata.proto

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>
 
 #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/drive.pb.h"
 #include "chrome/browser/chromeos/gdata/gdata_cache.h"
 #include "chrome/browser/chromeos/gdata/gdata_files.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.
+// See drive.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 = directory_service->CreateGDataDirectory();
   const std::string dir_name = "dir" + base::IntToString(sequence_id);
@@ skipping 147 matching lines @@
 }
 
 // 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,
+    scoped_ptr<DriveEntryProtoVector>* result,
     GDataFileError error,
-    scoped_ptr<GDataEntryProtoVector> entries) {
+    scoped_ptr<DriveEntryProtoVector> entries) {
   EXPECT_EQ(GDATA_FILE_OK, error);
   *result = entries.Pass();
 }
 
 }  // namespace
 
 TEST(GDataDirectoryServiceTest, VersionCheck) {
   // Set up the root directory.
-  GDataRootDirectoryProto proto;
-  GDataEntryProto* mutable_entry =
+  DriveRootDirectoryProto proto;
+  DriveEntryProto* 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);
   mutable_entry->set_title("drive");
 
   GDataDirectoryService directory_service;
 
   std::string serialized_proto;
   ASSERT_TRUE(proto.SerializeToString(&serialized_proto));
@@ skipping 100 matching lines @@
 TEST(GDataDirectoryServiceTest, GetEntryInfoByResourceId) {
   MessageLoopForUI message_loop;
   content::TestBrowserThread ui_thread(content::BrowserThread::UI,
                                        &message_loop);
   GDataDirectoryService directory_service;
   InitDirectoryService(&directory_service);
 
   // Confirm that an existing file is found.
   GDataFileError error = GDATA_FILE_ERROR_FAILED;
   FilePath drive_file_path;
-  scoped_ptr<GDataEntryProto> entry_proto;
+  scoped_ptr<DriveEntryProto> entry_proto;
   directory_service.GetEntryInfoByResourceId(
       "file_resource_id:file4",
       base::Bind(&test_util::CopyResultsFromGetEntryInfoWithFilePathCallback,
                  &error, &drive_file_path, &entry_proto));
   test_util::RunBlockingPoolTask();
   EXPECT_EQ(GDATA_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());
 
@@ skipping 11 matching lines @@
 
 TEST(GDataDirectoryServiceTest, GetEntryInfoByPath) {
   MessageLoopForUI message_loop;
   content::TestBrowserThread ui_thread(content::BrowserThread::UI,
                                        &message_loop);
   GDataDirectoryService directory_service;
   InitDirectoryService(&directory_service);
 
   // Confirm that an existing file is found.
   GDataFileError error = GDATA_FILE_ERROR_FAILED;
-  scoped_ptr<GDataEntryProto> entry_proto;
+  scoped_ptr<DriveEntryProto> entry_proto;
   directory_service.GetEntryInfoByPath(
       FilePath::FromUTF8Unsafe("drive/dir1/file4"),
       base::Bind(&test_util::CopyResultsFromGetEntryInfoCallback,
                  &error, &entry_proto));
   test_util::RunBlockingPoolTask();
   EXPECT_EQ(GDATA_FILE_OK, error);
   ASSERT_TRUE(entry_proto.get());
   EXPECT_EQ("file4", entry_proto->base_name());
 
   // Confirm that a non existing file is not found.
@@ skipping 10 matching lines @@
 
 TEST(GDataDirectoryServiceTest, ReadDirectoryByPath) {
   MessageLoopForUI message_loop;
   content::TestBrowserThread ui_thread(content::BrowserThread::UI,
                                        &message_loop);
   GDataDirectoryService directory_service;
   InitDirectoryService(&directory_service);
 
   // Confirm that an existing directory is found.
   GDataFileError error = GDATA_FILE_ERROR_FAILED;
-  scoped_ptr<GDataEntryProtoVector> entries;
+  scoped_ptr<DriveEntryProtoVector> entries;
   directory_service.ReadDirectoryByPath(
       FilePath::FromUTF8Unsafe("drive/dir1"),
       base::Bind(&test_util::CopyResultsFromReadDirectoryCallback,
                  &error, &entries));
   test_util::RunBlockingPoolTask();
   EXPECT_EQ(GDATA_FILE_OK, error);
   ASSERT_TRUE(entries.get());
   ASSERT_EQ(3U, entries->size());
 
   // The order is not guaranteed so we should sort the base names.
@@ skipping 124 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