add pepper video decoder glue and delegate

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 "app/surface/transport_dib.h"
 #include "base/logging.h"
 #include "base/scoped_ptr.h"
 #include "chrome/common/render_messages.h"
@@ skipping 139 matching lines @@
   // Make sure we don't call shutdown more than once.
   if (!stream_id_) {
     return;
   }
   filter_->Send(new ViewHostMsg_CloseAudioStream(0, stream_id_));
   filter_->RemoveDelegate(stream_id_);
   stream_id_ = 0;
   client_ = NULL;
 }
 
+// Implements the VideoDecoder.
+class PlatformVideoDecoderImpl
+    : public pepper::PluginDelegate::PlatformVideoDecoder {
+ public:
+  PlatformVideoDecoderImpl()
+      : input_buffer_size_(0),
+        next_dib_id_(0),
+        dib_(NULL) {
+    memset(&flush_callback_, 0, sizeof(flush_callback_));
+  }
+
+  virtual bool Init(const PP_VideoDecoderConfig& decoder_config) {
+    decoder_config_ = decoder_config;
+    input_buffer_size_ = 1024 << 4;
+
+    // Allocate the transport DIB.
+    TransportDIB* dib = TransportDIB::Create(input_buffer_size_,
+                                             next_dib_id_++);
+    if (!dib)
+      return false;
+
+    // TODO(wjia): Create video decoder in GPU process.
+
+    return true;
+  }
+
+  virtual bool Decode(PP_VideoCompressedDataBuffer& input_buffer) {
+    // TODO(wjia): Implement me!
+    NOTIMPLEMENTED();
+
+    input_buffers_.push(&input_buffer);
+
+    // Copy input data to dib_ and send it to GPU video decoder.
+
+    return false;
+  }
+
+  virtual int32_t Flush(PP_CompletionCallback& callback) {
+    // TODO(wjia): Implement me!
+    NOTIMPLEMENTED();
+
+    // Do nothing if there is a flush pending.
+    if (flush_callback_.func)
+      return PP_ERROR_BADARGUMENT;
+
+    flush_callback_ = callback;
+
+    // Call GPU video decoder to flush.
+
+    return PP_ERROR_WOULDBLOCK;
+  }
+
+  virtual bool ReturnUncompressedDataBuffer(
+      PP_VideoUncompressedDataBuffer& buffer) {
+    // TODO(wjia): Implement me!
+    NOTIMPLEMENTED();
+
+    // Deliver the buffer to GPU video decoder.
+
+    return false;
+  }
+
+  void OnFlushDone() {
+    if (!flush_callback_.func)
+      return;
+
+    flush_callback_.func(flush_callback_.user_data, PP_OK);
+    flush_callback_.func = NULL;
+  }
+
+  virtual intptr_t GetSharedMemoryHandle() const {
+    return reinterpret_cast<intptr_t>(dib_.get());
+  }
+
+ private:
+  size_t input_buffer_size_;
+  int next_dib_id_;
+  scoped_ptr<TransportDIB> dib_;
+  PP_VideoDecoderConfig decoder_config_;
+  std::queue<PP_VideoCompressedDataBuffer*> input_buffers_;
+  PP_CompletionCallback flush_callback_;
+
+  DISALLOW_COPY_AND_ASSIGN(PlatformVideoDecoderImpl);
+};
+
 }  // namespace
 
 PepperPluginDelegateImpl::PepperPluginDelegateImpl(RenderView* render_view)
     : render_view_(render_view) {
 }
 
 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.
@@ skipping 71 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::PlatformVideoDecoder*
+PepperPluginDelegateImpl::CreateVideoDecoder(
+    const PP_VideoDecoderConfig& decoder_config) {
+  scoped_ptr<PlatformVideoDecoderImpl> decoder(new PlatformVideoDecoderImpl());
+
+  if (!decoder->Init(decoder_config))
+    return NULL;
+
+  return decoder.release();
+}
+
 void PepperPluginDelegateImpl::DidChangeNumberOfFindResults(int identifier,
                                                            int total,
                                                            bool final_result) {
   if (total == 0) {
     render_view_->ReportNoFindInPageResults(identifier);
   } else {
     render_view_->reportFindInPageMatchCount(identifier, total, final_result);
   }
 }
 
@@ skipping 13 matching lines @@
   } else {
     return NULL;
   }
 }
 
 bool PepperPluginDelegateImpl::RunFileChooser(
     const WebKit::WebFileChooserParams& params,
     WebKit::WebFileChooserCompletion* chooser_completion) {
   return render_view_->runFileChooser(params, chooser_completion);
 }