Rename service/service_factory of file_system_provider and launcher_search_provider

chrome/browser/chromeos/file_system_provider/file_system_provider_service.cc

 // Copyright 2014 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/file_system_provider/service.h"
+#include "chrome/browser/chromeos/file_system_provider/file_system_provider_service.h"
 
 #include "base/files/file_path.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/stl_util.h"
 #include "base/values.h"
+#include "chrome/browser/chromeos/file_system_provider/file_system_provider_service_factory.h"
 #include "chrome/browser/chromeos/file_system_provider/mount_path_util.h"
 #include "chrome/browser/chromeos/file_system_provider/observer.h"
 #include "chrome/browser/chromeos/file_system_provider/provided_file_system.h"
 #include "chrome/browser/chromeos/file_system_provider/provided_file_system_info.h"
 #include "chrome/browser/chromeos/file_system_provider/registry.h"
 #include "chrome/browser/chromeos/file_system_provider/registry_interface.h"
-#include "chrome/browser/chromeos/file_system_provider/service_factory.h"
 #include "chrome/browser/chromeos/file_system_provider/throttled_file_system.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/common/permissions/api_permission.h"
 #include "extensions/common/permissions/permissions_data.h"
 #include "storage/browser/fileapi/external_mount_points.h"
 #include "storage/common/fileapi/file_system_mount_option.h"
 
 namespace chromeos {
@@ skipping 168 matching lines @@
 base::File::Error Service::UnmountFileSystem(const std::string& extension_id,
                                              const std::string& file_system_id,
                                              UnmountReason reason) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   const ProvidedFileSystemMap::iterator file_system_it =
       file_system_map_.find(FileSystemKey(extension_id, file_system_id));
   if (file_system_it == file_system_map_.end()) {
     const ProvidedFileSystemInfo empty_file_system_info;
     FOR_EACH_OBSERVER(
-        Observer,
-        observers_,
+        Observer, observers_,
         OnProvidedFileSystemUnmount(empty_file_system_info,
                                     base::File::FILE_ERROR_NOT_FOUND));
     return base::File::FILE_ERROR_NOT_FOUND;
   }
 
   storage::ExternalMountPoints* const mount_points =
       storage::ExternalMountPoints::GetSystemInstance();
   DCHECK(mount_points);
 
   const ProvidedFileSystemInfo& file_system_info =
       file_system_it->second->GetFileSystemInfo();
 
   const std::string mount_point_name =
       file_system_info.mount_path().BaseName().value();
   if (!mount_points->RevokeFileSystem(mount_point_name)) {
     FOR_EACH_OBSERVER(
-        Observer,
-        observers_,
+        Observer, observers_,
         OnProvidedFileSystemUnmount(file_system_info,
                                     base::File::FILE_ERROR_INVALID_OPERATION));
     return base::File::FILE_ERROR_INVALID_OPERATION;
   }
 
   FOR_EACH_OBSERVER(
-      Observer,
-      observers_,
+      Observer, observers_,
       OnProvidedFileSystemUnmount(file_system_info, base::File::FILE_OK));
 
   mount_point_name_to_key_map_.erase(mount_point_name);
 
   if (reason == UNMOUNT_REASON_USER) {
     registry_->ForgetFileSystem(file_system_info.extension_id(),
                                 file_system_info.file_system_id());
   }
 
   delete file_system_it->second;
   file_system_map_.erase(file_system_it);
 
   return base::File::FILE_OK;
 }
 
 bool Service::RequestUnmount(const std::string& extension_id,
                              const std::string& file_system_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   ProvidedFileSystemMap::iterator file_system_it =
       file_system_map_.find(FileSystemKey(extension_id, file_system_id));
   if (file_system_it == file_system_map_.end())
     return false;
 
-  file_system_it->second->RequestUnmount(
-      base::Bind(&Service::OnRequestUnmountStatus,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 file_system_it->second->GetFileSystemInfo()));
+  file_system_it->second->RequestUnmount(base::Bind(
+      &Service::OnRequestUnmountStatus, weak_ptr_factory_.GetWeakPtr(),
+      file_system_it->second->GetFileSystemInfo()));
   return true;
 }
 
 bool Service::RequestMount(const std::string& extension_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   extensions::EventRouter* const event_router =
       extensions::EventRouter::Get(profile_);
   DCHECK(event_router);
 
@@ skipping 10 matching lines @@
           scoped_ptr<base::ListValue>(new base::ListValue()))));
 
   return true;
 }
 
 std::vector<ProvidedFileSystemInfo> Service::GetProvidedFileSystemInfoList() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   std::vector<ProvidedFileSystemInfo> result;
   for (ProvidedFileSystemMap::const_iterator it = file_system_map_.begin();
-       it != file_system_map_.end();
-       ++it) {
+       it != file_system_map_.end(); ++it) {
     result.push_back(it->second->GetFileSystemInfo());
   }
   return result;
 }
 
 ProvidedFileSystemInterface* Service::GetProvidedFileSystem(
     const std::string& extension_id,
     const std::string& file_system_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
@@ skipping 116 matching lines @@
   return file_system_it->second;
 }
 
 void Service::OnRequestUnmountStatus(
     const ProvidedFileSystemInfo& file_system_info,
     base::File::Error error) {
   // Notify observers about failure in unmounting, since mount() will not be
   // called by the provided file system. In case of success mount() will be
   // invoked, and observers notified, so there is no need to call them now.
   if (error != base::File::FILE_OK) {
-    FOR_EACH_OBSERVER(Observer,
-                      observers_,
+    FOR_EACH_OBSERVER(Observer, observers_,
                       OnProvidedFileSystemUnmount(file_system_info, error));
   }
 }
 
 void Service::OnWatcherChanged(const ProvidedFileSystemInfo& file_system_info,
                                const Watcher& watcher,
                                storage::WatcherManager::ChangeType change_type,
                                const Changes& changes,
                                const base::Closure& callback) {
   callback.Run();
 }
 
 void Service::OnWatcherTagUpdated(
     const ProvidedFileSystemInfo& file_system_info,
     const Watcher& watcher) {
   PrefService* const pref_service = profile_->GetPrefs();
   DCHECK(pref_service);
 
   registry_->UpdateWatcherTag(file_system_info, watcher);
 }
 
 void Service::OnWatcherListChanged(
     const ProvidedFileSystemInfo& file_system_info,
     const Watchers& watchers) {
   registry_->RememberFileSystem(file_system_info, watchers);
 }
 
 }  // namespace file_system_provider
 }  // namespace chromeos