Cleanup: Deprecate DriveFileSyncService::kServiceName

chrome/browser/sync_file_system/drive_file_sync_service_mock_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/sync_file_system/drive_file_sync_service.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/message_loop.h"
@@ skipping 49 matching lines @@
 
 using extensions::Extension;
 using extensions::DictionaryBuilder;
 using extensions::ListBuilder;
 
 namespace sync_file_system {
 
 namespace {
 
 const char kRootResourceId[] = "folder:root";
-const char* kServiceName = DriveFileSyncService::kServiceName;
 
 base::FilePath::StringType ASCIIToFilePathString(const std::string& path) {
   return base::FilePath().AppendASCII(path).value();
 }
 
 void DidInitialize(bool* done, SyncStatusCode status, bool created) {
   EXPECT_FALSE(*done);
   *done = true;
   EXPECT_EQ(SYNC_STATUS_OK, status);
   EXPECT_TRUE(created);
@@ skipping 89 matching lines @@
 ACTION_P2(InvokeGetResourceListCallback2, error, result) {
   scoped_ptr<google_apis::ResourceList> resource_list(result.Pass());
   base::MessageLoopProxy::current()->PostTask(
       FROM_HERE,
       base::Bind(arg2, error, base::Passed(&resource_list)));
 }
 
 ACTION(PrepareForRemoteChange_Busy) {
   base::MessageLoopProxy::current()->PostTask(
       FROM_HERE,
-      base::Bind(arg2,
+      base::Bind(arg1,
                  SYNC_STATUS_FILE_BUSY,
                  SyncFileMetadata(),
                  FileChangeList()));
 }
 
 ACTION(PrepareForRemoteChange_NotFound) {
   base::MessageLoopProxy::current()->PostTask(
       FROM_HERE,
-      base::Bind(arg2,
+      base::Bind(arg1,
                  SYNC_STATUS_OK,
                  SyncFileMetadata(SYNC_FILE_TYPE_UNKNOWN, 0, base::Time()),
                  FileChangeList()));
 }
 
 ACTION(PrepareForRemoteChange_NotModified) {
   base::MessageLoopProxy::current()->PostTask(
       FROM_HERE,
-      base::Bind(arg2,
+      base::Bind(arg1,
                  SYNC_STATUS_OK,
                  SyncFileMetadata(SYNC_FILE_TYPE_FILE, 0, base::Time()),
                  FileChangeList()));
 }
 
 ACTION(InvokeDidDownloadFile) {
   base::MessageLoopProxy::current()->PostTask(
       FROM_HERE, base::Bind(arg3, google_apis::HTTP_SUCCESS, arg1));
 }
 
@@ skipping 45 matching lines @@
         static_cast<extensions::TestExtensionSystem*>(
             extensions::ExtensionSystem::Get(profile_.get())));
     extension_system->CreateExtensionService(
         CommandLine::ForCurrentProcess(), base::FilePath(), false);
     extension_service_ = extension_system->Get(
         profile_.get())->extension_service();
 
     AddTestExtension(extension_service_, FPL("example1"));
     AddTestExtension(extension_service_, FPL("example2"));
 
-    ASSERT_TRUE(RegisterSyncableFileSystem(kServiceName));
+    RegisterSyncableFileSystem();
 
     mock_drive_service_ = new NiceMock<google_apis::MockDriveService>;
 
     EXPECT_CALL(*mock_drive_service(), Initialize(profile_.get()));
     EXPECT_CALL(*mock_drive_service(), AddObserver(_));
 
     // Expect to call GetRootResourceId and RemoveResourceFromDirectory to
     // ensure the sync root directory is not in 'My Drive' directory.
     EXPECT_CALL(*mock_drive_service(), GetRootResourceId())
         .WillRepeatedly(Return(kRootResourceId));
@@ skipping 34 matching lines @@
     EXPECT_CALL(*mock_drive_service(), CancelAll());
 
     if (sync_service_) {
       sync_service_.reset();
     }
 
     metadata_store_.reset();
     api_util_.reset();
     mock_drive_service_ = NULL;
 
-    EXPECT_TRUE(RevokeSyncableFileSystem(kServiceName));
+    RevokeSyncableFileSystem();
 
     extension_service_ = NULL;
     profile_.reset();
     message_loop_.RunUntilIdle();
   }
 
   void SetSyncEnabled(bool enabled) {
     sync_service_->SetSyncEnabled(enabled);
   }
 
@@ skipping 61 matching lines @@
   std::map<GURL, std::string>* pending_batch_sync_origins() {
     return &(sync_service()->pending_batch_sync_origins_);
   }
 
   const RemoteChangeHandler& remote_change_handler() const {
     return sync_service_->remote_change_handler_;
   }
 
   fileapi::FileSystemURL CreateURL(const GURL& origin,
                                    const base::FilePath::StringType& path) {
-    return CreateSyncableFileSystemURL(
-        origin, kServiceName, base::FilePath(path));
+    return CreateSyncableFileSystemURL(origin, base::FilePath(path));
   }
 
   void ProcessRemoteChange(SyncStatusCode expected_status,
                            const fileapi::FileSystemURL& expected_url,
                            SyncFileStatus expected_sync_file_status,
                            SyncAction expected_sync_action,
                            SyncDirection expected_sync_direction) {
     SyncStatusCode actual_status = SYNC_STATUS_UNKNOWN;
     fileapi::FileSystemURL actual_url;
 
@@ skipping 387 matching lines @@
   const std::string kSyncRootResourceId("folder:sync_root_resource_id");
   const base::FilePath::StringType kFileName(FPL("File 1.mp3"));
 
   metadata_store()->SetSyncRootDirectory(kSyncRootResourceId);
   metadata_store()->AddIncrementalSyncOrigin(kOrigin, kDirectoryResourceId);
 
   EXPECT_CALL(*mock_remote_observer(), OnRemoteChangeQueueUpdated(_))
       .Times(AnyNumber());
 
   EXPECT_CALL(*mock_remote_processor(),
-              PrepareForProcessRemoteChange(CreateURL(kOrigin, kFileName),
-                                            kServiceName, _))
+              PrepareForProcessRemoteChange(CreateURL(kOrigin, kFileName), _))
       .WillOnce(PrepareForRemoteChange_Busy());
   EXPECT_CALL(*mock_remote_processor(),
               ClearLocalChanges(CreateURL(kOrigin, kFileName), _))
       .WillOnce(InvokeCompletionCallback());
 
   SetUpDriveServiceExpectCallsForIncrementalSync();
 
   SetUpDriveSyncService(true);
 
   scoped_ptr<ResourceEntry> entry(ResourceEntry::ExtractAndParse(
@@ skipping 14 matching lines @@
   const base::FilePath::StringType kFileName(FPL("File 1.mp3"));
   const std::string kFileResourceId("file:2_file_resource_id");
 
   metadata_store()->SetSyncRootDirectory(kSyncRootResourceId);
   metadata_store()->AddIncrementalSyncOrigin(kOrigin, kDirectoryResourceId);
 
   EXPECT_CALL(*mock_remote_observer(), OnRemoteChangeQueueUpdated(_))
       .Times(AnyNumber());
 
   EXPECT_CALL(*mock_remote_processor(),
-              PrepareForProcessRemoteChange(CreateURL(kOrigin, kFileName),
-                                            kServiceName, _))
+              PrepareForProcessRemoteChange(CreateURL(kOrigin, kFileName), _))
       .WillOnce(PrepareForRemoteChange_NotFound());
   EXPECT_CALL(*mock_remote_processor(),
               ClearLocalChanges(CreateURL(kOrigin, kFileName), _))
       .WillOnce(InvokeCompletionCallback());
 
   SetUpDriveServiceExpectCallsForDownloadFile(kFileResourceId);
 
   EXPECT_CALL(*mock_remote_processor(),
               ApplyRemoteChange(_, _, CreateURL(kOrigin, kFileName), _))
       .WillOnce(InvokeDidApplyRemoteChange());
@@ skipping 20 matching lines @@
   const base::FilePath::StringType kFileName(FPL("File 1.mp3"));
   const std::string kFileResourceId("file:2_file_resource_id");
 
   metadata_store()->SetSyncRootDirectory(kSyncRootResourceId);
   metadata_store()->AddIncrementalSyncOrigin(kOrigin, kDirectoryResourceId);
 
   EXPECT_CALL(*mock_remote_observer(), OnRemoteChangeQueueUpdated(_))
       .Times(AnyNumber());
 
   EXPECT_CALL(*mock_remote_processor(),
-              PrepareForProcessRemoteChange(CreateURL(kOrigin, kFileName),
-                                            kServiceName, _))
+              PrepareForProcessRemoteChange(CreateURL(kOrigin, kFileName), _))
       .WillOnce(PrepareForRemoteChange_NotModified());
   EXPECT_CALL(*mock_remote_processor(),
               ClearLocalChanges(CreateURL(kOrigin, kFileName), _))
       .WillOnce(InvokeCompletionCallback());
 
   SetUpDriveServiceExpectCallsForDownloadFile(kFileResourceId);
 
   EXPECT_CALL(*mock_remote_processor(),
               ApplyRemoteChange(_, _, CreateURL(kOrigin, kFileName), _))
       .WillOnce(InvokeDidApplyRemoteChange());
@@ skipping 135 matching lines @@
   entry->set_kind(google_apis::ENTRY_KIND_FOLDER);
 
   // Expect to drop this change for file.
   EXPECT_FALSE(AppendIncrementalRemoteChangeByEntry(
       kOrigin, *entry, 1));
 }
 
 #endif  // !defined(OS_ANDROID)
 
 }  // namespace sync_file_system