Cleanup: Deprecate DriveFileSyncService::kServiceName

webkit/browser/fileapi/syncable/canned_syncable_file_system.cc

 // Copyright 2013 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 "webkit/browser/fileapi/syncable/canned_syncable_file_system.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_util.h"
 #include "base/message_loop_proxy.h"
@@ skipping 159 matching lines @@
 void EnsureLastTaskRuns(base::SingleThreadTaskRunner* runner) {
   base::RunLoop run_loop;
   runner->PostTaskAndReply(
       FROM_HERE, base::Bind(&base::DoNothing), run_loop.QuitClosure());
   run_loop.Run();
 }
 
 }  // namespace
 
 CannedSyncableFileSystem::CannedSyncableFileSystem(
-    const GURL& origin, const std::string& service,
+    const GURL& origin,
     base::SingleThreadTaskRunner* io_task_runner,
     base::SingleThreadTaskRunner* file_task_runner)
-    : service_name_(service),
-      origin_(origin),
+    : origin_(origin),
       type_(fileapi::kFileSystemTypeSyncable),
       result_(base::PLATFORM_FILE_OK),
       sync_status_(sync_file_system::SYNC_STATUS_OK),
       io_task_runner_(io_task_runner),
       file_task_runner_(file_task_runner),
       is_filesystem_set_up_(false),
       is_filesystem_opened_(false),
       sync_status_observers_(new ObserverList) {
 }
 
@@ skipping 46 matching lines @@
   EXPECT_TRUE(is_filesystem_opened_);
 
   GURL url(root_url_.spec() + path);
   return file_system_context_->CrackURL(url);
 }
 
 PlatformFileError CannedSyncableFileSystem::OpenFileSystem() {
   EXPECT_TRUE(is_filesystem_set_up_);
   EXPECT_FALSE(is_filesystem_opened_);
   file_system_context_->OpenSyncableFileSystem(
-      service_name_, origin_, type_,
+      origin_, type_,
       fileapi::OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
       base::Bind(&CannedSyncableFileSystem::DidOpenFileSystem,
                  base::Unretained(this)));
   base::MessageLoop::current()->Run();
   if (file_system_context_->sync_context()) {
     // Register 'this' as a sync status observer.
     RunOnThread(
         io_task_runner_.get(),
         FROM_HERE,
         base::Bind(&CannedSyncableFileSystem::InitializeSyncStatusObserver,
@@ skipping 13 matching lines @@
 }
 
 SyncStatusCode CannedSyncableFileSystem::MaybeInitializeFileSystemContext(
     LocalFileSyncContext* sync_context) {
   DCHECK(sync_context);
   sync_status_ = sync_file_system::SYNC_STATUS_UNKNOWN;
   VerifySameTaskRunner(io_task_runner_.get(),
                        sync_context->io_task_runner_.get());
   sync_context->MaybeInitializeFileSystemContext(
       origin_,
-      service_name_,
       file_system_context_.get(),
       base::Bind(&CannedSyncableFileSystem::DidInitializeFileSystemContext,
                  base::Unretained(this)));
   base::MessageLoop::current()->Run();
   return sync_status_;
 }
 
 PlatformFileError CannedSyncableFileSystem::CreateDirectory(
     const FileSystemURL& url) {
   return RunOnThread<PlatformFileError>(
@@ skipping 330 matching lines @@
   sync_status_ = status;
   base::MessageLoop::current()->Quit();
 }
 
 void CannedSyncableFileSystem::InitializeSyncStatusObserver() {
   ASSERT_TRUE(io_task_runner_->RunsTasksOnCurrentThread());
   file_system_context_->sync_context()->sync_status()->AddObserver(this);
 }
 
 }  // namespace sync_file_system