Move us fully from gfx:: over to skia types for consistency.

remoting/client/plugin/pepper_view.cc

 // Copyright (c) 2011 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 "base/message_loop.h"
 #include "base/string_util.h"
 #include "ppapi/cpp/graphics_2d.h"
 #include "ppapi/cpp/image_data.h"
@@ skipping 56 matching lines @@
     // size!  Otherwise, this will just silently do nothing.
     graphics2d_.ReplaceContents(&image);
     FlushGraphics(base::Time::Now());
   } else {
     // TODO(ajwong): We need to keep a backing store image of the host screen
     // that has the data here which can be redrawn.
     return;
   }
 }
 
-void PepperView::SetHostSize(const gfx::Size& host_size) {
+void PepperView::SetHostSize(const SkISize& host_size) {
   DCHECK(context_->main_message_loop()->BelongsToCurrentThread());
 
   if (host_size_ == host_size)
     return;
 
   host_size_ = host_size;
 
   // Submit an update of desktop size to Javascript.
   instance_->GetScriptableObject()->SetDesktopSize(
       host_size.width(), host_size.height());
 }
 
-void PepperView::PaintFrame(media::VideoFrame* frame, UpdatedRects* rects) {
+void PepperView::PaintFrame(media::VideoFrame* frame, RectVector* rects) {
   DCHECK(context_->main_message_loop()->BelongsToCurrentThread());
 
-  SetHostSize(gfx::Size(frame->width(), frame->height()));
+  SetHostSize(SkISize::Make(frame->width(), frame->height()));
 
   if (!backing_store_.get() || backing_store_->is_null()) {
     LOG(ERROR) << "Backing store is not available.";
     return;
   }
 
   base::Time start_time = base::Time::Now();
 
   // Copy updated regions to the backing store and then paint the regions.
   bool changes_made = false;
   for (size_t i = 0; i < rects->size(); ++i)
     changes_made |= PaintRect(frame, (*rects)[i]);
 
   if (changes_made)
     FlushGraphics(start_time);
 }
 
-bool PepperView::PaintRect(media::VideoFrame* frame, const gfx::Rect& r) {
+bool PepperView::PaintRect(media::VideoFrame* frame, const SkIRect& r) {
   const uint8* frame_data = frame->data(media::VideoFrame::kRGBPlane);
   const int kFrameStride = frame->stride(media::VideoFrame::kRGBPlane);
   const int kBytesPerPixel = GetBytesPerPixel(media::VideoFrame::RGB32);
 
   pp::Size backing_store_size = backing_store_->size();
-  gfx::Rect rect = r.Intersect(gfx::Rect(0, 0, backing_store_size.width(),
-                                         backing_store_size.height()));
-
-  if (rect.IsEmpty())
+  SkIRect rect(r);
+  if (!rect.intersect(SkIRect::MakeWH(backing_store_size.width(),
+                                      backing_store_size.height()))) {
     return false;
+  }
 
   const uint8* in =
       frame_data +
-      kFrameStride * rect.y() +   // Y offset.
-      kBytesPerPixel * rect.x();  // X offset.
+      kFrameStride * rect.fTop +   // Y offset.
+      kBytesPerPixel * rect.fLeft;  // X offset.
   uint8* out =
       reinterpret_cast<uint8*>(backing_store_->data()) +
-      backing_store_->stride() * rect.y() +  // Y offset.
-      kBytesPerPixel * rect.x();  // X offset.
+      backing_store_->stride() * rect.fTop +  // Y offset.
+      kBytesPerPixel * rect.fLeft;  // X offset.
 
   // TODO(hclam): We really should eliminate this memory copy.
   for (int j = 0; j < rect.height(); ++j) {
     memcpy(out, in, rect.width() * kBytesPerPixel);
     in += kFrameStride;
     out += backing_store_->stride();
   }
 
   // Pepper Graphics 2D has a strange and badly documented API that the
   // point here is the offset from the source rect. Why?
   graphics2d_.PaintImageData(
       *backing_store_.get(),
       pp::Point(0, 0),
-      pp::Rect(rect.x(), rect.y(), rect.width(), rect.height()));
+      pp::Rect(rect.fLeft, rect.fTop, rect.width(), rect.height()));
   return true;
 }
 
 void PepperView::BlankRect(pp::ImageData& image_data, const pp::Rect& rect) {
   const int kBytesPerPixel = GetBytesPerPixel(media::VideoFrame::RGB32);
   for (int y = rect.y(); y < rect.bottom(); y++) {
     uint8* to = reinterpret_cast<uint8*>(image_data.data()) +
         (y * image_data.stride()) + (rect.x() * kBytesPerPixel);
     memset(to, 0xff, rect.width() * kBytesPerPixel);
   }
@@ skipping 77 matching lines @@
   DCHECK(context_->main_message_loop()->BelongsToCurrentThread());
 
   // TODO(hclam): Re-consider the way we communicate with Javascript.
   ChromotingScriptableObject* scriptable_obj = instance_->GetScriptableObject();
   if (success)
     scriptable_obj->SetConnectionInfo(STATUS_CONNECTED, QUALITY_UNKNOWN);
   else
     scriptable_obj->SignalLoginChallenge();
 }
 
-bool PepperView::SetPluginSize(const gfx::Size& plugin_size) {
+bool PepperView::SetPluginSize(const SkISize& plugin_size) {
   if (plugin_size_ == plugin_size)
     return false;
   plugin_size_ = plugin_size;
 
   pp::Size pp_size = pp::Size(plugin_size.width(), plugin_size.height());
 
   graphics2d_ = pp::Graphics2D(instance_, pp_size, true);
   if (!instance_->BindGraphics(graphics2d_)) {
     LOG(ERROR) << "Couldn't bind the device context.";
     return false;
   }
 
-  if (plugin_size.IsEmpty())
+  if (plugin_size.isEmpty())
     return false;
 
   // Allocate the backing store to save the desktop image.
   if ((backing_store_.get() == NULL) ||
       (backing_store_->size() != pp_size)) {
     VLOG(1) << "Allocate backing store: "
             << plugin_size.width() << " x " << plugin_size.height();
     backing_store_.reset(
         new pp::ImageData(instance_, pp::ImageData::GetNativeImageDataFormat(),
                           pp_size, false));
     DCHECK(backing_store_.get() && !backing_store_->is_null())
         << "Not enough memory for backing store.";
   }
   return true;
 }
 
 double PepperView::GetHorizontalScaleRatio() const {
   if (instance_->DoScaling()) {
-    DCHECK(!host_size_.IsEmpty());
+    DCHECK(!host_size_.isEmpty());
     return 1.0 * plugin_size_.width() / host_size_.width();
   }
   return 1.0;
 }
 
 double PepperView::GetVerticalScaleRatio() const {
   if (instance_->DoScaling()) {
-    DCHECK(!host_size_.IsEmpty());
+    DCHECK(!host_size_.isEmpty());
     return 1.0 * plugin_size_.height() / host_size_.height();
   }
   return 1.0;
 }
 
 void PepperView::AllocateFrame(media::VideoFrame::Format format,
                                size_t width,
                                size_t height,
                                base::TimeDelta timestamp,
                                base::TimeDelta duration,
@@ skipping 11 matching lines @@
 }
 
 void PepperView::ReleaseFrame(media::VideoFrame* frame) {
   DCHECK(context_->main_message_loop()->BelongsToCurrentThread());
 
   if (frame)
     frame->Release();
 }
 
 void PepperView::OnPartialFrameOutput(media::VideoFrame* frame,
-                                      UpdatedRects* rects,
+                                      RectVector* rects,
                                       Task* done) {
   DCHECK(context_->main_message_loop()->BelongsToCurrentThread());
 
   // TODO(ajwong): Clean up this API to be async so we don't need to use a
   // member variable as a hack.
   PaintFrame(frame, rects);
   done->Run();
   delete done;
 }
 
 void PepperView::OnPaintDone(base::Time paint_start) {
   DCHECK(context_->main_message_loop()->BelongsToCurrentThread());
   instance_->GetStats()->video_paint_ms()->Record(
       (base::Time::Now() - paint_start).InMilliseconds());
 
   // If the last flush failed because there was already another one in progress
   // then we perform the flush now.
   if (flush_blocked_)
     FlushGraphics(base::Time::Now());
   return;
 }
 
 }  // namespace remoting