Replace FilePath with base::FilePath.

content/renderer/pepper/pepper_plugin_delegate_impl.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 "content/renderer/pepper/pepper_plugin_delegate_impl.h"
 
 #include <cmath>
 #include <cstddef>
 #include <map>
 #include <queue>
@@ skipping 253 matching lines @@
       close_file_callback_(close_file_callback) {
   }
 
   virtual ~AsyncOpenFileSystemURLCallbackTranslator() {}
 
   virtual void DidSucceed() OVERRIDE {
     NOTREACHED();
   }
   virtual void DidReadMetadata(
       const base::PlatformFileInfo& file_info,
-      const FilePath& platform_path) OVERRIDE {
+      const base::FilePath& platform_path) OVERRIDE {
     NOTREACHED();
   }
   virtual void DidCreateSnapshotFile(
       const base::PlatformFileInfo& file_info,
       const base::FilePath& platform_path) OVERRIDE {
     NOTREACHED();
   }
   virtual void DidReadDirectory(
       const std::vector<base::FileUtilProxy::Entry>& entries,
       bool has_more) OVERRIDE {
@@ skipping 85 matching lines @@
   return NULL;
 }
 
 scoped_refptr<webkit::ppapi::PluginModule>
 PepperPluginDelegateImpl::CreatePepperPluginModule(
     const webkit::WebPluginInfo& webplugin_info,
     bool* pepper_plugin_was_registered) {
   *pepper_plugin_was_registered = true;
 
   // See if a module has already been loaded for this plugin.
-  FilePath path(webplugin_info.path);
+  base::FilePath path(webplugin_info.path);
   scoped_refptr<webkit::ppapi::PluginModule> module =
       PepperPluginRegistry::GetInstance()->GetLiveModule(path);
   if (module) {
     if (!module->GetEmbedderState()) {
       // If the module exists and no embedder state was associated with it,
       // then the module was one of the ones preloaded and is an in-process
       // plugin. We need to associate our host state with it.
       CreateHostForInProcessModule(render_view_, module, webplugin_info);
     }
     return module;
@@ skipping 41 matching lines @@
                                 peer_pid,
                                 plugin_child_id,
                                 false))  // is_external = false
     return scoped_refptr<webkit::ppapi::PluginModule>();
 
   return module;
 }
 
 RendererPpapiHost* PepperPluginDelegateImpl::CreateExternalPluginModule(
     scoped_refptr<webkit::ppapi::PluginModule> module,
-    const FilePath& path,
+    const base::FilePath& path,
     ppapi::PpapiPermissions permissions,
     const IPC::ChannelHandle& channel_handle,
     base::ProcessId peer_pid,
     int plugin_child_id) {
   // We don't call PepperPluginRegistry::AddLiveModule, as this module is
   // managed externally.
   return CreateOutOfProcessModule(module,
                                   path,
                                   permissions,
                                   channel_handle,
                                   peer_pid,
                                   plugin_child_id,
                                   true);  // is_external = true
 }
 
 scoped_refptr<PepperBrokerImpl> PepperPluginDelegateImpl::CreateBroker(
     webkit::ppapi::PluginModule* plugin_module) {
   DCHECK(plugin_module);
   DCHECK(!plugin_module->GetBroker());
 
   // The broker path is the same as the plugin.
-  const FilePath& broker_path = plugin_module->path();
+  const base::FilePath& broker_path = plugin_module->path();
 
   scoped_refptr<PepperBrokerImpl> broker =
       new PepperBrokerImpl(plugin_module, this);
 
   int request_id =
       pending_connect_broker_.Add(new scoped_refptr<PepperBrokerImpl>(broker));
 
   // Have the browser start the broker process for us.
   IPC::Message* msg =
       new ViewHostMsg_OpenChannelToPpapiBroker(render_view_->routing_id(),
                                                request_id,
                                                broker_path);
   if (!render_view_->Send(msg)) {
     pending_connect_broker_.Remove(request_id);
     return scoped_refptr<PepperBrokerImpl>();
   }
 
   return broker;
 }
 
 RendererPpapiHost* PepperPluginDelegateImpl::CreateOutOfProcessModule(
     webkit::ppapi::PluginModule* module,
-    const FilePath& path,
+    const base::FilePath& path,
     ppapi::PpapiPermissions permissions,
     const IPC::ChannelHandle& channel_handle,
     base::ProcessId peer_pid,
     int plugin_child_id,
     bool is_external) {
   scoped_refptr<PepperHungPluginFilter> hung_filter(
       new PepperHungPluginFilter(path,
                                  render_view_->routing_id(),
                                  plugin_child_id));
   scoped_ptr<HostDispatcherWrapper> dispatcher(
@@ skipping 298 matching lines @@
   RendererPpapiHostImpl* host_impl = static_cast<RendererPpapiHostImpl*>(
       instance->module()->GetEmbedderState());
   return host_impl->CreateInProcessResourceCreationAPI(instance);
 }
 
 SkBitmap* PepperPluginDelegateImpl::GetSadPluginBitmap() {
   return GetContentClient()->renderer()->GetSadPluginBitmap();
 }
 
 WebKit::WebPlugin* PepperPluginDelegateImpl::CreatePluginReplacement(
-    const FilePath& file_path) {
+    const base::FilePath& file_path) {
   return GetContentClient()->renderer()->CreatePluginReplacement(
       render_view_, file_path);
 }
 
 webkit::ppapi::PluginDelegate::PlatformImage2D*
 PepperPluginDelegateImpl::CreateImage2D(int width, int height) {
   return PepperPlatformImage2DImpl::Create(width, height);
 }
 
 webkit::ppapi::PluginDelegate::PlatformGraphics2D*
@@ skipping 134 matching lines @@
       webkit::ppapi::ResourceHelper::GetPluginModule(client);
   if (!plugin_module)
     return;
 
   PepperBrokerImpl* broker =
       static_cast<PepperBrokerImpl*>(plugin_module->GetBroker());
   broker->OnBrokerPermissionResult(client, result);
 }
 
 bool PepperPluginDelegateImpl::AsyncOpenFile(
-    const FilePath& path,
+    const base::FilePath& path,
     int flags,
     const AsyncOpenFileCallback& callback) {
   int message_id = pending_async_open_files_.Add(
       new AsyncOpenFileCallback(callback));
   IPC::Message* msg = new ViewHostMsg_AsyncOpenFile(
       render_view_->routing_id(), path, flags, message_id);
   return render_view_->Send(msg);
 }
 
 void PepperPluginDelegateImpl::OnAsyncFileOpened(
@@ skipping 138 matching lines @@
 
   FileSystemDispatcher* file_system_dispatcher =
       ChildThread::current()->file_system_dispatcher();
   return file_system_dispatcher->OpenFile(path, flags,
       new AsyncOpenFileSystemURLCallbackTranslator(
           callback,
           base::Bind(&DoNotifyCloseFile, path)));
 }
 
 void PepperPluginDelegateImpl::SyncGetFileSystemPlatformPath(
-    const GURL& url, FilePath* platform_path) {
+    const GURL& url, base::FilePath* platform_path) {
   RenderThreadImpl::current()->Send(new FileSystemHostMsg_SyncGetPlatformPath(
       url, platform_path));
 }
 
 scoped_refptr<base::MessageLoopProxy>
 PepperPluginDelegateImpl::GetFileThreadMessageLoopProxy() {
   return RenderThreadImpl::current()->GetFileThreadMessageLoopProxy();
 }
 
 uint32 PepperPluginDelegateImpl::TCPSocketCreate() {
@@ skipping 462 matching lines @@
     RenderWidgetFullscreenPepper* container =
         static_cast<RenderWidgetFullscreenPepper*>(
             instance->fullscreen_container());
     return container->mouse_lock_dispatcher();
   } else {
     return render_view_->mouse_lock_dispatcher();
   }
 }
 
 }  // namespace content