Cleanup: Deprecate DriveFileSyncService::kServiceName

chrome/browser/sync_file_system/sync_file_system_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 <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/run_loop.h"
 #include "base/stl_util.h"
@@ skipping 22 matching lines @@
 using ::testing::InvokeWithoutArgs;
 using ::testing::Return;
 using ::testing::StrictMock;
 using ::testing::_;
 
 namespace sync_file_system {
 
 namespace {
 
 const char kOrigin[] = "http://example.com";
-const char kServiceName[] = "test";
 
 template <typename R> struct AssignTrait {
   typedef const R& ArgumentType;
 };
 
 template <> struct AssignTrait<SyncFileStatus> {
   typedef SyncFileStatus ArgumentType;
 };
 
 template <typename R>
@@ skipping 59 matching lines @@
 
 class SyncFileSystemServiceTest : public testing::Test {
  protected:
   SyncFileSystemServiceTest() {}
   virtual ~SyncFileSystemServiceTest() {}
 
   virtual void SetUp() OVERRIDE {
     thread_helper_.SetUp();
 
     file_system_.reset(new CannedSyncableFileSystem(
-        GURL(kOrigin), kServiceName,
+        GURL(kOrigin),
         thread_helper_.io_task_runner(),
         thread_helper_.file_task_runner()));
 
     local_service_ = new LocalFileSyncService(&profile_);
     remote_service_ = new StrictMock<MockRemoteFileSyncService>;
     sync_service_.reset(new SyncFileSystemService(&profile_));
 
     EXPECT_CALL(*mock_remote_service(),
                 AddServiceObserver(sync_service_.get())).Times(1);
     EXPECT_CALL(*mock_remote_service(),
@@ skipping 12 matching lines @@
     EXPECT_CALL(*mock_remote_service(), SetSyncEnabled(false)).Times(1);
     sync_service_->SetSyncEnabledForTesting(false);
 
     file_system_->SetUp();
   }
 
   virtual void TearDown() OVERRIDE {
     sync_service_->Shutdown();
 
     file_system_->TearDown();
-    RevokeSyncableFileSystem(kServiceName);
+    RevokeSyncableFileSystem();
     thread_helper_.TearDown();
   }
 
   void InitializeApp() {
     base::RunLoop run_loop;
     SyncStatusCode status = SYNC_STATUS_UNKNOWN;
 
     EXPECT_CALL(*mock_remote_service(),
                 RegisterOriginForTrackingChanges(GURL(kOrigin), _)).Times(1);
 
     sync_service_->InitializeForApp(
         file_system_->file_system_context(),
-        kServiceName, GURL(kOrigin),
+        GURL(kOrigin),
         AssignAndQuitCallback(&run_loop, &status));
     run_loop.Run();
 
     EXPECT_EQ(SYNC_STATUS_OK, status);
     EXPECT_EQ(base::PLATFORM_FILE_OK, file_system_->OpenFileSystem());
   }
 
   // Calls InitializeForApp after setting up the mock remote service to
   // perform following when RegisterOriginForTrackingChanges is called:
   //  1. Notify RemoteFileSyncService's observers of |state_to_notify|
@@ skipping 22 matching lines @@
                                          status_to_return));
 
     std::vector<SyncServiceState> actual_states;
     EXPECT_CALL(event_observer, OnSyncStateUpdated(GURL(), _, _))
         .WillRepeatedly(RecordState(&actual_states));
 
     SyncStatusCode actual_status = SYNC_STATUS_UNKNOWN;
     base::RunLoop run_loop;
     sync_service_->InitializeForApp(
         file_system_->file_system_context(),
-        kServiceName, GURL(kOrigin),
+        GURL(kOrigin),
         AssignAndQuitCallback(&run_loop, &actual_status));
     run_loop.Run();
 
     EXPECT_EQ(expected_status, actual_status);
     ASSERT_EQ(expected_states.size(), actual_states.size());
     for (size_t i = 0; i < actual_states.size(); ++i)
       EXPECT_EQ(expected_states[i], actual_states[i]);
   }
 
   FileSystemURL URL(const std::string& path) const {
@@ skipping 261 matching lines @@
         base::Bind(&AssignValueAndQuit<SyncFileStatus>,
                    &run_loop, &status, &sync_file_status));
     run_loop.Run();
 
     EXPECT_EQ(SYNC_STATUS_OK, status);
     EXPECT_EQ(SYNC_FILE_STATUS_CONFLICTING, sync_file_status);
   }
 }
 
 }  // namespace sync_file_system