Abstract PPAPI's ImageData behind webrtc::DesktopFrame interface

remoting/client/rectangle_update_decoder.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/rectangle_update_decoder.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
-#include "ppapi/cpp/image_data.h"
 #include "remoting/base/util.h"
 #include "remoting/codec/video_decoder.h"
 #include "remoting/codec/video_decoder_verbatim.h"
 #include "remoting/codec/video_decoder_vp8.h"
 #include "remoting/client/frame_consumer.h"
+#include "remoting/client/image_buffer.h"
 #include "remoting/protocol/session_config.h"
 
 using base::Passed;
 using remoting::protocol::ChannelConfig;
 using remoting::protocol::SessionConfig;
 
 namespace remoting {
 
 RectangleUpdateDecoder::RectangleUpdateDecoder(
     scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
@@ skipping 87 matching lines @@
 
   // If the view size is empty or we have no output buffers ready, return.
   if (buffers_.empty() || view_size_.isEmpty())
     return;
 
   // If no Decoder is initialized, or the host dimensions are empty, return.
   if (!decoder_.get() || source_size_.isEmpty())
     return;
 
   // Draw the invalidated region to the buffer.
-  pp::ImageData* buffer = buffers_.front();
+  ImageBuffer* buffer = buffers_.front();
   SkRegion output_region;
   decoder_->RenderFrame(view_size_, clip_area_,
-                        reinterpret_cast<uint8*>(buffer->data()),
+                        buffer->data(),
                         buffer->stride(),
                         &output_region);
 
   // Notify the consumer that painting is done.
   if (!output_region.isEmpty()) {
     buffers_.pop_front();
     consumer_->ApplyBuffer(view_size_, clip_area_, buffer, output_region);
   }
 }
 
 void RectangleUpdateDecoder::RequestReturnBuffers(const base::Closure& done) {
   if (!decode_task_runner_->BelongsToCurrentThread()) {
     decode_task_runner_->PostTask(
         FROM_HERE, base::Bind(&RectangleUpdateDecoder::RequestReturnBuffers,
         this, done));
     return;
   }
 
   while (!buffers_.empty()) {
     consumer_->ReturnBuffer(buffers_.front());
     buffers_.pop_front();
   }
 
   if (!done.is_null())
     done.Run();
 }
 
-void RectangleUpdateDecoder::DrawBuffer(pp::ImageData* buffer) {
+void RectangleUpdateDecoder::DrawBuffer(ImageBuffer* buffer) {
   if (!decode_task_runner_->BelongsToCurrentThread()) {
     decode_task_runner_->PostTask(
         FROM_HERE, base::Bind(&RectangleUpdateDecoder::DrawBuffer,
                               this, buffer));
     return;
   }
 
-  DCHECK(clip_area_.width() <= buffer->size().width() &&
-         clip_area_.height() <= buffer->size().height());
+  DCHECK(clip_area_.width() <= buffer->width() &&
+         clip_area_.height() <= buffer->height());
 
   buffers_.push_back(buffer);
   SchedulePaint();
 }
 
 void RectangleUpdateDecoder::InvalidateRegion(const SkRegion& region) {
   if (!decode_task_runner_->BelongsToCurrentThread()) {
     decode_task_runner_->PostTask(
         FROM_HERE, base::Bind(&RectangleUpdateDecoder::InvalidateRegion,
                               this, region));
@@ skipping 22 matching lines @@
     decoder_->Invalidate(view_size, region);
   }
 
   if (view_size_ != view_size ||
       clip_area_ != clip_area) {
     view_size_ = view_size;
     clip_area_ = clip_area;
 
     // Return buffers that are smaller than needed to the consumer for
     // reuse/reallocation.
-    std::list<pp::ImageData*>::iterator i = buffers_.begin();
+    std::list<ImageBuffer*>::iterator i = buffers_.begin();
     while (i != buffers_.end()) {
-      pp::Size buffer_size = (*i)->size();
-      if (buffer_size.width() < clip_area_.width() ||
-          buffer_size.height() < clip_area_.height()) {
+      if ((*i)->width() < clip_area_.width() ||
+          (*i)->height() < clip_area_.height()) {
         consumer_->ReturnBuffer(*i);
         i = buffers_.erase(i);
       } else {
         ++i;
       }
     }
 
     SchedulePaint();
   }
 }
@@ skipping 65 matching lines @@
 
   done.Run();
 }
 
 ChromotingStats* RectangleUpdateDecoder::GetStats() {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   return &stats_;
 }
 
 }  // namespace remoting