Remove dependency on Skia from chromoting client.

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/callback.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
@@ skipping 13 matching lines @@
 
 namespace remoting {
 
 RectangleUpdateDecoder::RectangleUpdateDecoder(
     scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> decode_task_runner,
     scoped_refptr<FrameConsumerProxy> consumer)
     : main_task_runner_(main_task_runner),
       decode_task_runner_(decode_task_runner),
       consumer_(consumer),
-      source_size_(SkISize::Make(0, 0)),
-      source_dpi_(SkIPoint::Make(0, 0)),
-      view_size_(SkISize::Make(0, 0)),
-      clip_area_(SkIRect::MakeEmpty()),
       paint_scheduled_(false),
       latest_sequence_number_(0) {
 }
 
 RectangleUpdateDecoder::~RectangleUpdateDecoder() {
 }
 
 void RectangleUpdateDecoder::Initialize(const SessionConfig& config) {
   // Initialize decoder based on the selected codec.
   ChannelConfig::Codec codec = config.video_config().codec;
@@ skipping 11 matching lines @@
   DCHECK(decode_task_runner_->BelongsToCurrentThread());
 
   base::ScopedClosureRunner done_runner(done);
 
   bool decoder_needs_reset = false;
   bool notify_size_or_dpi_change = false;
 
   // If the packet includes screen size or DPI information, store them.
   if (packet->format().has_screen_width() &&
       packet->format().has_screen_height()) {
-    SkISize source_size = SkISize::Make(packet->format().screen_width(),
-                                        packet->format().screen_height());
-    if (source_size_ != source_size) {
+    webrtc::DesktopSize source_size(packet->format().screen_width(),
+                                    packet->format().screen_height());
+    if (!source_size_.equals(source_size)) {
       source_size_ = source_size;
       decoder_needs_reset = true;
       notify_size_or_dpi_change = true;
     }
   }
   if (packet->format().has_x_dpi() && packet->format().has_y_dpi()) {
-    SkIPoint source_dpi(SkIPoint::Make(packet->format().x_dpi(),
-                                       packet->format().y_dpi()));
-    if (source_dpi != source_dpi_) {
+    webrtc::DesktopVector source_dpi(packet->format().x_dpi(),
+                                     packet->format().y_dpi());
+    if (!source_dpi.equals(source_dpi_)) {
       source_dpi_ = source_dpi;
       notify_size_or_dpi_change = true;
     }
   }
 
   // If we've never seen a screen size, ignore the packet.
-  if (source_size_.isZero())
+  if (source_size_.is_empty())
     return;
 
   if (decoder_needs_reset)
     decoder_->Initialize(source_size_);
   if (notify_size_or_dpi_change)
     consumer_->SetSourceSize(source_size_, source_dpi_);
 
   if (!decoder_->IsReadyForData()) {
     // TODO(ajwong): This whole thing should move into an invalid state.
     LOG(ERROR) << "Decoder is unable to process data. Dropping packet.";
@@ skipping 10 matching lines @@
   paint_scheduled_ = true;
   decode_task_runner_->PostTask(
       FROM_HERE, base::Bind(&RectangleUpdateDecoder::DoPaint, this));
 }
 
 void RectangleUpdateDecoder::DoPaint() {
   DCHECK(paint_scheduled_);
   paint_scheduled_ = false;
 
   // If the view size is empty or we have no output buffers ready, return.
-  if (buffers_.empty() || view_size_.isEmpty())
+  if (buffers_.empty() || view_size_.is_empty())
     return;
 
   // If no Decoder is initialized, or the host dimensions are empty, return.
-  if (!decoder_.get() || source_size_.isEmpty())
+  if (!decoder_.get() || source_size_.is_empty())
     return;
 
   // Draw the invalidated region to the buffer.
   webrtc::DesktopFrame* buffer = buffers_.front();
-  SkRegion output_region;
+  webrtc::DesktopRegion output_region;
   decoder_->RenderFrame(view_size_, clip_area_,
                         buffer->data(),
                         buffer->stride(),
                         &output_region);
 
   // Notify the consumer that painting is done.
-  if (!output_region.isEmpty()) {
+  if (!output_region.is_empty()) {
     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));
@@ skipping 17 matching lines @@
     return;
   }
 
   DCHECK(clip_area_.width() <= buffer->size().width() &&
          clip_area_.height() <= buffer->size().height());
 
   buffers_.push_back(buffer);
   SchedulePaint();
 }
 
-void RectangleUpdateDecoder::InvalidateRegion(const SkRegion& region) {
+void RectangleUpdateDecoder::InvalidateRegion(
+    const webrtc::DesktopRegion& region) {
   if (!decode_task_runner_->BelongsToCurrentThread()) {
     decode_task_runner_->PostTask(
         FROM_HERE, base::Bind(&RectangleUpdateDecoder::InvalidateRegion,
                               this, region));
     return;
   }
 
   if (decoder_.get()) {
     decoder_->Invalidate(view_size_, region);
     SchedulePaint();
   }
 }
 
-void RectangleUpdateDecoder::SetOutputSizeAndClip(const SkISize& view_size,
-                                                  const SkIRect& clip_area) {
+void RectangleUpdateDecoder::SetOutputSizeAndClip(
+    const webrtc::DesktopSize& view_size,
+    const webrtc::DesktopRect& clip_area) {
   if (!decode_task_runner_->BelongsToCurrentThread()) {
     decode_task_runner_->PostTask(
         FROM_HERE, base::Bind(&RectangleUpdateDecoder::SetOutputSizeAndClip,
                               this, view_size, clip_area));
     return;
   }
 
   // The whole frame needs to be repainted if the scaling factor has changed.
-  if (view_size_ != view_size && decoder_.get()) {
-    SkRegion region;
-    region.op(SkIRect::MakeSize(view_size), SkRegion::kUnion_Op);
+  if (!view_size_.equals(view_size) && decoder_.get()) {
+    webrtc::DesktopRegion region;
+    region.AddRect(webrtc::DesktopRect::MakeSize(view_size));
     decoder_->Invalidate(view_size, region);
   }
 
-  if (view_size_ != view_size ||
-      clip_area_ != clip_area) {
+  if (!view_size_.equals(view_size) ||
+      !clip_area_.equals(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<webrtc::DesktopFrame*>::iterator i = buffers_.begin();
     while (i != buffers_.end()) {
       if ((*i)->size().width() < clip_area_.width() ||
           (*i)->size().height() < clip_area_.height()) {
         consumer_->ReturnBuffer(*i);
         i = buffers_.erase(i);
       } else {
         ++i;
       }
     }
 
     SchedulePaint();
   }
 }
 
-const SkRegion* RectangleUpdateDecoder::GetBufferShape() {
+const webrtc::DesktopRegion* RectangleUpdateDecoder::GetBufferShape() {
   return decoder_->GetImageShape();
 }
 
 void RectangleUpdateDecoder::ProcessVideoPacket(scoped_ptr<VideoPacket> packet,
                                                 const base::Closure& done) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   // If the video packet is empty then drop it. Empty packets are used to
   // maintain activity on the network.
   if (!packet->has_data() || packet->data().size() == 0) {
@@ skipping 45 matching lines @@
 
   done.Run();
 }
 
 ChromotingStats* RectangleUpdateDecoder::GetStats() {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   return &stats_;
 }
 
 }  // namespace remoting