Move the Pepper implementation from webkit/glue/plugins/pepper_* to...

chrome/renderer/pepper_plugin_delegate_impl.cc

 // Copyright (c) 2010 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/renderer/pepper_plugin_delegate_impl.h"
 
 #include <cmath>
 
 #include "app/l10n_util.h"
 #include "app/surface/transport_dib.h"
@@ skipping 23 matching lines @@
 #include "gfx/size.h"
 #include "grit/locale_settings.h"
 #include "ipc/ipc_channel_handle.h"
 #include "ppapi/c/dev/pp_video_dev.h"
 #include "ppapi/proxy/host_dispatcher.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebFileChooserCompletion.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebFileChooserParams.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebPluginContainer.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebView.h"
 #include "webkit/fileapi/file_system_callback_dispatcher.h"
-#include "webkit/glue/plugins/pepper_file_io.h"
-#include "webkit/glue/plugins/pepper_plugin_instance.h"
-#include "webkit/glue/plugins/pepper_plugin_module.h"
 #include "webkit/glue/plugins/webplugin.h"
+#include "webkit/plugins/ppapi/ppb_file_io_impl.h"
+#include "webkit/plugins/ppapi/plugin_instance.h"
+#include "webkit/plugins/ppapi/plugin_module.h"
 
 #if defined(OS_MACOSX)
 #include "chrome/common/render_messages.h"
 #include "chrome/renderer/render_thread.h"
 #endif
 
 #if defined(OS_POSIX)
 #include "ipc/ipc_channel_posix.h"
 #endif
 
 using WebKit::WebView;
 
 namespace {
 
 const int32 kDefaultCommandBufferSize = 1024 * 1024;
 
 // Implements the Image2D using a TransportDIB.
-class PlatformImage2DImpl : public pepper::PluginDelegate::PlatformImage2D {
+class PlatformImage2DImpl
+    : public webkit::ppapi::PluginDelegate::PlatformImage2D {
  public:
   // This constructor will take ownership of the dib pointer.
   PlatformImage2DImpl(int width, int height, TransportDIB* dib)
       : width_(width),
         height_(height),
         dib_(dib) {
   }
 
   virtual skia::PlatformCanvas* Map() {
     return dib_->GetPlatformCanvas(width_, height_);
@@ skipping 17 matching lines @@
  private:
   int width_;
   int height_;
   scoped_ptr<TransportDIB> dib_;
 
   DISALLOW_COPY_AND_ASSIGN(PlatformImage2DImpl);
 };
 
 
 class PlatformAudioImpl
-    : public pepper::PluginDelegate::PlatformAudio,
+    : public webkit::ppapi::PluginDelegate::PlatformAudio,
       public AudioMessageFilter::Delegate,
       public base::RefCountedThreadSafe<PlatformAudioImpl> {
  public:
   explicit PlatformAudioImpl(scoped_refptr<AudioMessageFilter> filter)
       : client_(NULL), filter_(filter), stream_id_(0),
         main_message_loop_(MessageLoop::current()) {
     DCHECK(filter_);
   }
 
   virtual ~PlatformAudioImpl() {
     // Make sure we have been shut down.
     DCHECK_EQ(0, stream_id_);
     DCHECK(!client_);
   }
 
   // Initialize this audio context. StreamCreated() will be called when the
   // stream is created.
   bool Initialize(uint32_t sample_rate, uint32_t sample_count,
-       pepper::PluginDelegate::PlatformAudio::Client* client);
+       webkit::ppapi::PluginDelegate::PlatformAudio::Client* client);
 
   virtual bool StartPlayback() {
     return filter_ && filter_->Send(
         new ViewHostMsg_PlayAudioStream(0, stream_id_));
   }
 
   virtual bool StopPlayback() {
     return filter_ && filter_->Send(
         new ViewHostMsg_PauseAudioStream(0, stream_id_));
   }
@@ skipping 11 matching lines @@
     LOG(FATAL) << "Should never get OnCreated in PlatformAudioImpl";
   }
 
   virtual void OnLowLatencyCreated(base::SharedMemoryHandle handle,
                                    base::SyncSocket::Handle socket_handle,
                                    uint32 length);
 
   virtual void OnVolume(double volume) { }
 
   // The client to notify when the stream is created.
-  pepper::PluginDelegate::PlatformAudio::Client* client_;
+  webkit::ppapi::PluginDelegate::PlatformAudio::Client* client_;
   // MessageFilter used to send/receive IPC.
   scoped_refptr<AudioMessageFilter> filter_;
   // Our ID on the MessageFilter.
   int32 stream_id_;
 
   MessageLoop* main_message_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(PlatformAudioImpl);
 };
 
 bool PlatformAudioImpl::Initialize(
     uint32_t sample_rate, uint32_t sample_count,
-    pepper::PluginDelegate::PlatformAudio::Client* client) {
+    webkit::ppapi::PluginDelegate::PlatformAudio::Client* client) {
 
   DCHECK(client);
   // Make sure we don't call init more than once.
   DCHECK_EQ(0, stream_id_);
 
   client_ = client;
 
   ViewHostMsg_Audio_CreateStream_Params params;
   params.params.format = AudioParameters::AUDIO_PCM_LINEAR;
   params.params.channels = 2;
@@ skipping 39 matching lines @@
   stream_id_ = 0;
   client_ = NULL;
 
   // Release on the IO thread so that we avoid race problems with
   // OnLowLatencyCreated.
   filter_->message_loop()->ReleaseSoon(FROM_HERE, this);
 }
 
 // Implements the VideoDecoder.
 class PlatformVideoDecoderImpl
-    : public pepper::PluginDelegate::PlatformVideoDecoder {
+    : public webkit::ppapi::PluginDelegate::PlatformVideoDecoder {
  public:
   PlatformVideoDecoderImpl()
       : input_buffer_size_(0),
         next_dib_id_(0),
         dib_(NULL) {
     memset(&decoder_config_, 0, sizeof(decoder_config_));
     memset(&flush_callback_, 0, sizeof(flush_callback_));
   }
 
   virtual bool Init(const PP_VideoDecoderConfig_Dev& decoder_config) {
@@ skipping 63 matching lines @@
   size_t input_buffer_size_;
   int next_dib_id_;
   scoped_ptr<TransportDIB> dib_;
   PP_VideoDecoderConfig_Dev decoder_config_;
   std::queue<PP_VideoCompressedDataBuffer_Dev*> input_buffers_;
   PP_CompletionCallback flush_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(PlatformVideoDecoderImpl);
 };
 
-class DispatcherWrapper : public pepper::PluginDelegate::OutOfProcessProxy {
+class DispatcherWrapper
+    : public webkit::ppapi::PluginDelegate::OutOfProcessProxy {
  public:
   DispatcherWrapper() {}
   virtual ~DispatcherWrapper() {}
 
   bool Init(base::ProcessHandle plugin_process_handle,
             IPC::ChannelHandle channel_handle,
             PP_Module pp_module,
             pp::proxy::Dispatcher::GetInterfaceFunc local_get_interface);
 
   // OutOfProcessProxy implementation.
@@ skipping 37 matching lines @@
 }  // namespace
 
 PepperPluginDelegateImpl::PepperPluginDelegateImpl(RenderView* render_view)
     : render_view_(render_view),
       id_generator_(0) {
 }
 
 PepperPluginDelegateImpl::~PepperPluginDelegateImpl() {
 }
 
-scoped_refptr<pepper::PluginModule>
+scoped_refptr<webkit::ppapi::PluginModule>
 PepperPluginDelegateImpl::CreatePepperPlugin(const FilePath& path) {
   // Easy case is in-process plugins.
   if (!PepperPluginRegistry::GetInstance()->RunOutOfProcessForPlugin(path))
     return PepperPluginRegistry::GetInstance()->GetModule(path);
 
   // Out of process: have the browser start the plugin process for us.
   base::ProcessHandle plugin_process_handle = NULL;
   IPC::ChannelHandle channel_handle;
   render_view_->Send(new ViewHostMsg_OpenChannelToPepperPlugin(
       path, &plugin_process_handle, &channel_handle));
   if (channel_handle.name.empty())
-    return scoped_refptr<pepper::PluginModule>();  // Couldn't be initialized.
+    return scoped_refptr<webkit::ppapi::PluginModule>();  // Couldn't be initialized.
 
   // Create a new HostDispatcher for the proxying, and hook it to a new
   // PluginModule.
-  scoped_refptr<pepper::PluginModule> module(new pepper::PluginModule);
+  scoped_refptr<webkit::ppapi::PluginModule> module(
+      new webkit::ppapi::PluginModule);
   scoped_ptr<DispatcherWrapper> dispatcher(new DispatcherWrapper);
-  if (!dispatcher->Init(plugin_process_handle, channel_handle,
-                        module->pp_module(),
-                        pepper::PluginModule::GetLocalGetInterfaceFunc()))
-    return scoped_refptr<pepper::PluginModule>();
+  if (!dispatcher->Init(
+          plugin_process_handle, channel_handle,
+          module->pp_module(),
+          webkit::ppapi::PluginModule::GetLocalGetInterfaceFunc()))
+    return scoped_refptr<webkit::ppapi::PluginModule>();
   module->InitAsProxied(dispatcher.release());
   return module;
 }
 
 void PepperPluginDelegateImpl::ViewInitiatedPaint() {
   // Notify all of our instances that we started painting. This is used for
   // internal bookkeeping only, so we know that the set can not change under
   // us.
-  for (std::set<pepper::PluginInstance*>::iterator i =
+  for (std::set<webkit::ppapi::PluginInstance*>::iterator i =
            active_instances_.begin();
        i != active_instances_.end(); ++i)
     (*i)->ViewInitiatedPaint();
 }
 
 void PepperPluginDelegateImpl::ViewFlushedPaint() {
   // Notify all instances that we painted. This will call into the plugin, and
   // we it may ask to close itself as a result. This will, in turn, modify our
   // set, possibly invalidating the iterator. So we iterate on a copy that
   // won't change out from under us.
-  std::set<pepper::PluginInstance*> plugins = active_instances_;
-  for (std::set<pepper::PluginInstance*>::iterator i = plugins.begin();
+  std::set<webkit::ppapi::PluginInstance*> plugins = active_instances_;
+  for (std::set<webkit::ppapi::PluginInstance*>::iterator i = plugins.begin();
        i != plugins.end(); ++i) {
     // The copy above makes sure our iterator is never invalid if some plugins
     // are destroyed. But some plugin may decide to close all of its views in
     // response to a paint in one of them, so we need to make sure each one is
     // still "current" before using it.
     //
     // It's possible that a plugin was destroyed, but another one was created
     // with the same address. In this case, we'll call ViewFlushedPaint on that
     // new plugin. But that's OK for this particular case since we're just
     // notifying all of our instances that the view flushed, and the new one is
     // one of our instances.
     //
     // What about the case where a new one is created in a callback at a new
     // address and we don't issue the callback? We're still OK since this
     // callback is used for flush callbacks and we could not have possibly
     // started a new paint (ViewInitiatedPaint) for the new plugin while
     // processing a previous paint for an existing one.
     if (active_instances_.find(*i) != active_instances_.end())
       (*i)->ViewFlushedPaint();
   }
 }
 
 bool PepperPluginDelegateImpl::GetBitmapForOptimizedPluginPaint(
     const gfx::Rect& paint_bounds,
     TransportDIB** dib,
     gfx::Rect* location,
     gfx::Rect* clip) {
-  for (std::set<pepper::PluginInstance*>::iterator i =
+  for (std::set<webkit::ppapi::PluginInstance*>::iterator i =
            active_instances_.begin();
        i != active_instances_.end(); ++i) {
-    pepper::PluginInstance* instance = *i;
+    webkit::ppapi::PluginInstance* instance = *i;
     if (instance->GetBitmapForOptimizedPluginPaint(
             paint_bounds, dib, location, clip))
       return true;
   }
   return false;
 }
 
 void PepperPluginDelegateImpl::InstanceCreated(
-    pepper::PluginInstance* instance) {
+    webkit::ppapi::PluginInstance* instance) {
   active_instances_.insert(instance);
 
   // Set the initial focus.
   instance->SetContentAreaFocus(render_view_->has_focus());
 }
 
 void PepperPluginDelegateImpl::InstanceDeleted(
-    pepper::PluginInstance* instance) {
+    webkit::ppapi::PluginInstance* instance) {
   active_instances_.erase(instance);
 }
 
-pepper::PluginDelegate::PlatformImage2D*
+webkit::ppapi::PluginDelegate::PlatformImage2D*
 PepperPluginDelegateImpl::CreateImage2D(int width, int height) {
   uint32 buffer_size = width * height * 4;
 
   // Allocate the transport DIB and the PlatformCanvas pointing to it.
 #if defined(OS_MACOSX)
   // On the Mac, shared memory has to be created in the browser in order to
   // work in the sandbox.  Do this by sending a message to the browser
   // requesting a TransportDIB (see also
   // chrome/renderer/webplugin_delegate_proxy.cc, method
   // WebPluginDelegateProxy::CreateBitmap() for similar code).  Note that the
@@ skipping 15 matching lines @@
 #else
   static int next_dib_id = 0;
   TransportDIB* dib = TransportDIB::Create(buffer_size, next_dib_id++);
   if (!dib)
     return NULL;
 #endif
 
   return new PlatformImage2DImpl(width, height, dib);
 }
 
-pepper::PluginDelegate::PlatformContext3D*
+webkit::ppapi::PluginDelegate::PlatformContext3D*
     PepperPluginDelegateImpl::CreateContext3D() {
 #ifdef ENABLE_GPU
   WebGraphicsContext3DCommandBufferImpl* context =
       static_cast<WebGraphicsContext3DCommandBufferImpl*>(
           render_view_->webview()->graphicsContext3D());
   if (!context)
     return NULL;
 
   ggl::Context* parent_context = context->context();
   if (!parent_context)
     return NULL;
 
   return new PlatformContext3DImpl(parent_context);
 #else
   return NULL;
 #endif
 }
 
-pepper::PluginDelegate::PlatformVideoDecoder*
+webkit::ppapi::PluginDelegate::PlatformVideoDecoder*
 PepperPluginDelegateImpl::CreateVideoDecoder(
     const PP_VideoDecoderConfig_Dev& decoder_config) {
   scoped_ptr<PlatformVideoDecoderImpl> decoder(new PlatformVideoDecoderImpl());
 
   if (!decoder->Init(decoder_config))
     return NULL;
 
   return decoder.release();
 }
 
 void PepperPluginDelegateImpl::NumberOfFindResultsChanged(int identifier,
                                                           int total,
                                                           bool final_result) {
   render_view_->reportFindInPageMatchCount(identifier, total, final_result);
 }
 
 void PepperPluginDelegateImpl::SelectedFindResultChanged(int identifier,
                                                          int index) {
   render_view_->reportFindInPageSelection(
       identifier, index + 1, WebKit::WebRect());
 }
 
-pepper::PluginDelegate::PlatformAudio* PepperPluginDelegateImpl::CreateAudio(
+webkit::ppapi::PluginDelegate::PlatformAudio*
+PepperPluginDelegateImpl::CreateAudio(
     uint32_t sample_rate, uint32_t sample_count,
-    pepper::PluginDelegate::PlatformAudio::Client* client) {
+    webkit::ppapi::PluginDelegate::PlatformAudio::Client* client) {
   scoped_refptr<PlatformAudioImpl> audio(
       new PlatformAudioImpl(render_view_->audio_message_filter()));
   if (audio->Initialize(sample_rate, sample_count, client)) {
 
     // Also note ReleaseSoon invoked in PlatformAudioImpl::ShutDown().
     return audio.release();
   } else {
     return NULL;
   }
 }
@@ skipping 21 matching lines @@
     int message_id) {
   AsyncOpenFileCallback* callback =
       messages_waiting_replies_.Lookup(message_id);
   DCHECK(callback);
   messages_waiting_replies_.Remove(message_id);
   callback->Run(error_code, file);
   delete callback;
 }
 
 void PepperPluginDelegateImpl::OnSetFocus(bool has_focus) {
-  for (std::set<pepper::PluginInstance*>::iterator i =
+  for (std::set<webkit::ppapi::PluginInstance*>::iterator i =
          active_instances_.begin();
        i != active_instances_.end(); ++i)
     (*i)->SetContentAreaFocus(has_focus);
 }
 
 bool PepperPluginDelegateImpl::OpenFileSystem(
     const GURL& url,
     fileapi::FileSystemType type,
     long long size,
     fileapi::FileSystemCallbackDispatcher* dispatcher) {
@@ skipping 152 matching lines @@
   base::PlatformFileError error;
   IPC::Message* msg = new PepperFileMsg_QueryFile(full_path, info, &error);
   if (!render_view_->Send(msg)) {
     return base::PLATFORM_FILE_ERROR_FAILED;
   }
   return error;
 }
 base::PlatformFileError PepperPluginDelegateImpl::GetModuleLocalDirContents(
       const std::string& module_name,
       const FilePath& path,
-      PepperDirContents* contents) {
+      webkit::ppapi::DirContents* contents) {
   FilePath full_path = GetModuleLocalFilePath(module_name, path);
   if (full_path.empty()) {
     return base::PLATFORM_FILE_ERROR_ACCESS_DENIED;
   }
   base::PlatformFileError error;
   IPC::Message* msg =
       new PepperFileMsg_GetDirContents(full_path, contents, &error);
   if (!render_view_->Send(msg)) {
     return base::PLATFORM_FILE_ERROR_FAILED;
   }
   return error;
 }
 
 scoped_refptr<base::MessageLoopProxy>
 PepperPluginDelegateImpl::GetFileThreadMessageLoopProxy() {
   return RenderThread::current()->GetFileThreadMessageLoopProxy();
 }
 
-pepper::FullscreenContainer*
+webkit::ppapi::FullscreenContainer*
 PepperPluginDelegateImpl::CreateFullscreenContainer(
-    pepper::PluginInstance* instance) {
+    webkit::ppapi::PluginInstance* instance) {
   return render_view_->CreatePepperFullscreenContainer(instance);
 }
 
 std::string PepperPluginDelegateImpl::GetDefaultEncoding() {
   // TODO(brettw) bug 56615: Somehow get the preference for the default
   // encoding here rather than using the global default for the UI language.
   return l10n_util::GetStringUTF8(IDS_DEFAULT_ENCODING);
 }
 
 void PepperPluginDelegateImpl::ZoomLimitsChanged(double minimum_factor,
@@ skipping 17 matching lines @@
 }
 
 void PepperPluginDelegateImpl::DidStopLoading() {
   render_view_->DidStopLoadingForPlugin();
 }
 
 void PepperPluginDelegateImpl::SetContentRestriction(int restrictions) {
   render_view_->Send(new ViewHostMsg_UpdateContentRestrictions(
       render_view_->routing_id(), restrictions));
 }