Cleanup: Deprecate DriveFileSyncService::kServiceName

chrome/browser/sync_file_system/drive_metadata_store_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_metadata_store.h"
 
 #include <utility>
 
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
@@ skipping 15 matching lines @@
 
 #define FPL FILE_PATH_LITERAL
 
 using content::BrowserThread;
 
 namespace sync_file_system {
 
 namespace {
 
 const char kOrigin[] = "chrome-extension://example";
-const char* const kServiceName = DriveFileSyncService::kServiceName;
 
 typedef DriveMetadataStore::ResourceIdByOrigin ResourceIdByOrigin;
 typedef DriveMetadataStore::OriginByResourceId OriginByResourceId;
 
 fileapi::FileSystemURL URL(const base::FilePath& path) {
-  return CreateSyncableFileSystemURL(GURL(kOrigin), kServiceName, path);
+  return CreateSyncableFileSystemURL(GURL(kOrigin), path);
 }
 
 std::string GetResourceID(const ResourceIdByOrigin& sync_origins,
                           const GURL& origin) {
   ResourceIdByOrigin::const_iterator itr = sync_origins.find(origin);
   if (itr == sync_origins.end())
     return std::string();
   return itr->second;
 }
 
@@ skipping 19 matching lines @@
   virtual ~DriveMetadataStoreTest() {}
 
   virtual void SetUp() OVERRIDE {
     file_thread_.reset(new base::Thread("Thread_File"));
     file_thread_->Start();
 
     ui_task_runner_ = base::MessageLoopProxy::current();
     file_task_runner_ = file_thread_->message_loop_proxy();
 
     ASSERT_TRUE(base_dir_.CreateUniqueTempDir());
-    ASSERT_TRUE(RegisterSyncableFileSystem(kServiceName));
+    RegisterSyncableFileSystem();
   }
 
   virtual void TearDown() OVERRIDE {
-    EXPECT_TRUE(RevokeSyncableFileSystem(kServiceName));
+    RevokeSyncableFileSystem();
 
     DropDatabase();
     file_thread_->Stop();
     message_loop_.RunUntilIdle();
   }
 
  protected:
   void InitializeDatabase() {
     EXPECT_TRUE(ui_task_runner_->RunsTasksOnCurrentThread());
 
@@ skipping 411 matching lines @@
   metadata_store()->AddIncrementalSyncOrigin(kOrigin1, kResourceId1);
   metadata_store()->AddIncrementalSyncOrigin(kOrigin2, kResourceId2);
   metadata_store()->AddIncrementalSyncOrigin(kOrigin3, kResourceId3);
   DisableOrigin(kOrigin3);
   EXPECT_EQ(2u, metadata_store()->incremental_sync_origins().size());
   EXPECT_EQ(1u, metadata_store()->disabled_origins().size());
 
   EXPECT_EQ(SYNC_STATUS_OK,
             UpdateEntry(
                 CreateSyncableFileSystemURL(
-                    kOrigin1, kServiceName, base::FilePath(FPL("guf"))),
+                    kOrigin1, base::FilePath(FPL("guf"))),
                 CreateMetadata("foo", "spam", false, false)));
   EXPECT_EQ(SYNC_STATUS_OK,
             UpdateEntry(
                 CreateSyncableFileSystemURL(
-                    kOrigin2, kServiceName, base::FilePath(FPL("mof"))),
+                    kOrigin2, base::FilePath(FPL("mof"))),
                 CreateMetadata("bar", "ham", false, false)));
   EXPECT_EQ(SYNC_STATUS_OK,
             UpdateEntry(
                 CreateSyncableFileSystemURL(
-                    kOrigin3, kServiceName, base::FilePath(FPL("waf"))),
+                    kOrigin3, base::FilePath(FPL("waf"))),
                 CreateMetadata("baz", "egg", false, false)));
 
   EXPECT_EQ(SYNC_STATUS_OK, RemoveOrigin(kOrigin2));
   EXPECT_EQ(SYNC_STATUS_OK, RemoveOrigin(kOrigin3));
 
   DropDatabase();
   InitializeDatabase();
 
   // kOrigin1 should be the only one left.
   EXPECT_EQ(1u, metadata_store()->incremental_sync_origins().size());
@@ skipping 63 matching lines @@
   metadata_store()->AddIncrementalSyncOrigin(kOrigin1, kResourceId1);
   VerifyIncrementalSyncOrigin(kOrigin1, kResourceId1);
   VerifyReverseMap();
 
   metadata_store()->SetOriginRootDirectory(kOrigin1, kResourceId2);
   VerifyIncrementalSyncOrigin(kOrigin1, kResourceId2);
   VerifyReverseMap();
 }
 
 }  // namespace sync_file_system