Abstract PPAPI's ImageData behind webrtc::DesktopFrame interface

remoting/client/plugin/pepper_view.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 "remoting/client/plugin/pepper_view.h"
 
 #include <functional>
 
 #include "base/message_loop.h"
 #include "base/strings/string_util.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/time/time.h"
 #include "ppapi/cpp/completion_callback.h"
 #include "ppapi/cpp/dev/graphics_2d_dev.h"
 #include "ppapi/cpp/dev/view_dev.h"
 #include "ppapi/cpp/image_data.h"
 #include "ppapi/cpp/point.h"
 #include "ppapi/cpp/rect.h"
 #include "ppapi/cpp/size.h"
 #include "remoting/base/util.h"
 #include "remoting/client/chromoting_stats.h"
 #include "remoting/client/client_context.h"
 #include "remoting/client/frame_producer.h"
 #include "remoting/client/plugin/chromoting_instance.h"
 #include "remoting/client/plugin/pepper_util.h"
+#include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
 
 using base::Passed;
 
+namespace {
+
+// DesktopFrame that wraps a supplied pp::ImageData
+class PepperDesktopFrame : public webrtc::DesktopFrame {
+ public:
+  // Wraps the supplied ImageData.
+  explicit PepperDesktopFrame(const pp::ImageData& buffer);
+
+  // Access to underlying pepper representation.
+  const pp::ImageData& buffer() const {
+    return buffer_;
+  }
+
+ private:
+  pp::ImageData buffer_;
+};
+
+PepperDesktopFrame::PepperDesktopFrame(const pp::ImageData& buffer)
+  : DesktopFrame(webrtc::DesktopSize(buffer.size().width(),
+                                     buffer.size().height()),
+                 buffer.stride(),
+                 reinterpret_cast<uint8_t*>(buffer.data()),
+                 NULL),
+    buffer_(buffer) {}
+
+}  // namespace
+
 namespace remoting {
 
 namespace {
 
 // The maximum number of image buffers to be allocated at any point of time.
 const size_t kMaxPendingBuffersCount = 2;
 
 }  // namespace
 
 PepperView::PepperView(ChromotingInstance* instance,
@@ skipping 93 matching lines @@
   }
 
   if (view_changed) {
     producer_->SetOutputSizeAndClip(view_size_, clip_area_);
     InitiateDrawing();
   }
 }
 
 void PepperView::ApplyBuffer(const SkISize& view_size,
                              const SkIRect& clip_area,
-                             pp::ImageData* buffer,
+                             webrtc::DesktopFrame* buffer,
                              const SkRegion& region) {
   DCHECK(context_->main_task_runner()->BelongsToCurrentThread());
 
   if (!frame_received_) {
     instance_->OnFirstFrameReceived();
     frame_received_ = true;
   }
   // We cannot use the data in the buffer if its dimensions don't match the
   // current view size.
   // TODO(alexeypa): We could rescale and draw it (or even draw it without
   // rescaling) to reduce the perceived lag while we are waiting for
   // the properly scaled data.
   if (view_size_ != view_size) {
     FreeBuffer(buffer);
     InitiateDrawing();
   } else {
     FlushBuffer(clip_area, buffer, region);
   }
 }
 
-void PepperView::ReturnBuffer(pp::ImageData* buffer) {
+void PepperView::ReturnBuffer(webrtc::DesktopFrame* buffer) {
   DCHECK(context_->main_task_runner()->BelongsToCurrentThread());
 
   // Reuse the buffer if it is large enough, otherwise drop it on the floor
   // and allocate a new one.
   if (buffer->size().width() >= clip_area_.width() &&
       buffer->size().height() >= clip_area_.height()) {
     producer_->DrawBuffer(buffer);
   } else {
     FreeBuffer(buffer);
     InitiateDrawing();
   }
 }
 
 void PepperView::SetSourceSize(const SkISize& source_size,
                                const SkIPoint& source_dpi) {
   DCHECK(context_->main_task_runner()->BelongsToCurrentThread());
 
   if (source_size_ == source_size && source_dpi_ == source_dpi)
     return;
 
   source_size_ = source_size;
   source_dpi_ = source_dpi;
 
   // Notify JavaScript of the change in source size.
   instance_->SetDesktopSize(source_size, source_dpi);
 }
 
-pp::ImageData* PepperView::AllocateBuffer() {
+webrtc::DesktopFrame* PepperView::AllocateBuffer() {
   if (buffers_.size() >= kMaxPendingBuffersCount)
     return NULL;
 
-  pp::Size pp_size = pp::Size(clip_area_.width(), clip_area_.height());
-  if (pp_size.IsEmpty())
+  if (clip_area_.width()==0 || clip_area_.height()==0)
     return NULL;
 
   // Create an image buffer of the required size, but don't zero it.
-  pp::ImageData* buffer =  new pp::ImageData(
-      instance_, PP_IMAGEDATAFORMAT_BGRA_PREMUL, pp_size, false);
-  if (buffer->is_null()) {
+  pp::ImageData buffer_data(instance_,
+                    PP_IMAGEDATAFORMAT_BGRA_PREMUL,
+                    pp::Size(clip_area_.width(),
+                             clip_area_.height()),
+                    false);
+  if (buffer_data.is_null()) {
     LOG(WARNING) << "Not enough memory for frame buffers.";
-    delete buffer;
     return NULL;
   }
 
+  webrtc::DesktopFrame* buffer = new PepperDesktopFrame(buffer_data);
   buffers_.push_back(buffer);
   return buffer;
 }
 
-void PepperView::FreeBuffer(pp::ImageData* buffer) {
+void PepperView::FreeBuffer(webrtc::DesktopFrame* buffer) {
   DCHECK(std::find(buffers_.begin(), buffers_.end(), buffer) != buffers_.end());
 
   buffers_.remove(buffer);
   delete buffer;
 }
 
 void PepperView::InitiateDrawing() {
-  pp::ImageData* buffer = AllocateBuffer();
+  webrtc::DesktopFrame* buffer = AllocateBuffer();
   while (buffer) {
     producer_->DrawBuffer(buffer);
     buffer = AllocateBuffer();
   }
 }
 
 void PepperView::FlushBuffer(const SkIRect& clip_area,
-                             pp::ImageData* buffer,
+                             webrtc::DesktopFrame* buffer,
                              const SkRegion& region) {
   // Defer drawing if the flush is already in progress.
   if (flush_pending_) {
     // |merge_buffer_| is guaranteed to be free here because we allocate only
     // two buffers simultaneously. If more buffers are allowed this code should
     // apply all pending changes to the screen.
     DCHECK(merge_buffer_ == NULL);
 
     merge_clip_area_ = clip_area;
     merge_buffer_ = buffer;
@@ skipping 11 matching lines @@
     // the latter could change from the time the buffer was drawn.
     if (!rect.intersect(clip_area_))
       continue;
 
     // Specify the rectangle coordinates relative to the clipping area.
     rect.offset(-clip_area.left(), -clip_area.top());
 
     // Pepper Graphics 2D has a strange and badly documented API that the
     // point here is the offset from the source rect. Why?
     graphics2d_.PaintImageData(
-        *buffer,
+        static_cast<PepperDesktopFrame*>(buffer)->buffer(),
         pp::Point(clip_area.left(), clip_area.top()),
         pp::Rect(rect.left(), rect.top(), rect.width(), rect.height()));
   }
 
   // Notify the producer that some parts of the region weren't painted because
   // the clipping area has changed already.
   if (clip_area != clip_area_) {
     SkRegion not_painted = region;
     not_painted.op(clip_area_, SkRegion::kDifference_Op);
     if (!not_painted.isEmpty()) {
       producer_->InvalidateRegion(not_painted);
     }
   }
 
   // Flush the updated areas to the screen.
   int error = graphics2d_.Flush(
       PpCompletionCallback(base::Bind(
           &PepperView::OnFlushDone, AsWeakPtr(), start_time, buffer)));
   CHECK(error == PP_OK_COMPLETIONPENDING);
   flush_pending_ = true;
 
   // If the buffer we just rendered has a shape then pass that to JavaScript.
   const SkRegion* buffer_shape = producer_->GetBufferShape();
   if (buffer_shape)
     instance_->SetDesktopShape(*buffer_shape);
 }
 
 void PepperView::OnFlushDone(base::Time paint_start,
-                             pp::ImageData* buffer,
+                             webrtc::DesktopFrame* buffer,
                              int result) {
   DCHECK(context_->main_task_runner()->BelongsToCurrentThread());
   DCHECK(flush_pending_);
 
   instance_->GetStats()->video_paint_ms()->Record(
       (base::Time::Now() - paint_start).InMilliseconds());
 
   flush_pending_ = false;
   ReturnBuffer(buffer);
 
   // If there is a buffer queued for rendering then render it now.
   if (merge_buffer_ != NULL) {
     buffer = merge_buffer_;
     merge_buffer_ = NULL;
     FlushBuffer(merge_clip_area_, buffer, merge_region_);
   }
 }
 
 }  // namespace remoting