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/protocol/session_config.h"
+#include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
 
 using base::Passed;
 using remoting::protocol::ChannelConfig;
 using remoting::protocol::SessionConfig;
 
 namespace remoting {
 
 RectangleUpdateDecoder::RectangleUpdateDecoder(
     scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> decode_task_runner,
@@ skipping 86 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();
+  webrtc::DesktopFrame* 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(webrtc::DesktopFrame* 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());
 
@@ skipping 31 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<webrtc::DesktopFrame*>::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)->size().width() < clip_area_.width() ||
+          (*i)->size().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