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_desktop_frame.h"
 #include "remoting/client/plugin/pepper_util.h"
 
 using base::Passed;
 
 namespace remoting {
 
 namespace {
 
 // The maximum number of image buffers to be allocated at any point of time.
 const size_t kMaxPendingBuffersCount = 2;
@@ skipping 97 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()) {
+  webrtc::DesktopFrame* buffer = PepperDesktopFrame::Create(
+      instance_, clip_area_.width(), clip_area_.height());
+  if (static_cast<PepperDesktopFrame*>(buffer)->data_object().is_null()) {
     LOG(WARNING) << "Not enough memory for frame buffers.";
     delete buffer;
     return NULL;
   }
 
   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)->data_object(),
         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