Change Chromoting client to use Pepper's new Resource-base InputEvents.

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 112 matching lines @@
         backing_store_->stride() * r.y() + kBytesPerPixel * r.x();
 
     // TODO(hclam): We really should eliminate this memory copy.
     for (int j = 0; j < r.height(); ++j) {
       memcpy(out, in, r.width() * kBytesPerPixel);
       in += kFrameStride;
       out += backing_store_->stride();
     }
 
     if (DoScaling()) {
-      gfx::Rect r_scaled = UpdateScaledBackingStore(r);
+      pp::Rect r_scaled = UpdateScaledBackingStore(
+          pp::Rect(r.x(), r.y(), r.width(), r.height()));
       graphics2d_.PaintImageData(*scaled_backing_store_.get(), pp::Point(0, 0),
-                                 pp::Rect(r_scaled.x(), r_scaled.y(),
-                                          r_scaled.width(), r_scaled.height()));
+                                 r_scaled);
     } else {
       // 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(r.x(), r.y(), r.width(), r.height()));
     }
   }
 
   graphics2d_.Flush(TaskToCompletionCallback(
       task_factory_.NewRunnableMethod(&PepperView::OnPaintDone,
                                       base::Time::Now())));
 
   TraceContext::tracer()->PrintString("End Paint Frame.");
 }
 
-gfx::Rect PepperView::UpdateScaledBackingStore(const gfx::Rect& r) {
+pp::Rect PepperView::UpdateScaledBackingStore(const pp::Rect& r) {
   const int kBytesPerPixel = GetBytesPerPixel(media::VideoFrame::RGB32);
   // Find the updated rectangle in the scaled backing store.
-  gfx::Point top_left = ConvertHostToScreen(r.origin());
-  gfx::Point bottom_right = ConvertHostToScreen(gfx::Point(r.right(),
-                                                           r.bottom()));
+  pp::Point top_left = ConvertHostToScreen(r.point());
+  pp::Point bottom_right = ConvertHostToScreen(pp::Point(r.right(),
+                                                         r.bottom()));
   int r_scaled_left = top_left.x();
   int r_scaled_right = bottom_right.x();
   int r_scaled_top = top_left.y();
   int r_scaled_bottom = bottom_right.y();
   if (r_scaled_right <= r_scaled_left || r_scaled_bottom <= r_scaled_top)
-    return gfx::Rect(r_scaled_left, r_scaled_top, 0, 0);
+    return pp::Rect(r_scaled_left, r_scaled_top, 0, 0);
 
   // Allow for the fact that ConvertHostToScreen and ConvertScreenToHost aren't
   // exact inverses.
   r_scaled_right++;
   r_scaled_bottom++;
 
   // Clip the scaled rectangle.
   r_scaled_left = std::max(r_scaled_left, 0);
   r_scaled_left = std::min(r_scaled_left, client_width_);
   r_scaled_right = std::max(r_scaled_right, 0);
   r_scaled_right = std::min(r_scaled_right, client_width_);
   r_scaled_top = std::max(r_scaled_top, 0);
   r_scaled_top = std::min(r_scaled_top, client_height_);
   r_scaled_bottom = std::max(r_scaled_bottom, 0);
   r_scaled_bottom = std::min(r_scaled_bottom, client_height_);
 
   // Blit from the backing store to the scaled backing store.
   for (int y_scaled = r_scaled_top; y_scaled < r_scaled_bottom; y_scaled++) {
-    int y = ConvertScreenToHost(gfx::Point(0, y_scaled)).y();
+    int y = ConvertScreenToHost(pp::Point(0, y_scaled)).y();
     // Special case where each pixel is a word.
     if ((kBytesPerPixel == 4) && (backing_store_->stride() % 4 == 0) &&
         (scaled_backing_store_->stride() % 4 == 0)) {
       uint32* from = reinterpret_cast<uint32*>(backing_store_->data()) +
           (y * backing_store_->stride() / 4);
       uint32* to = reinterpret_cast<uint32*>(scaled_backing_store_->data()) +
           (y_scaled * scaled_backing_store_->stride() / 4) + r_scaled_left;
       uint32* to_max = to + (r_scaled_right - r_scaled_left);
       const int* offset = &screen_x_to_host_x_[r_scaled_left];
       while (to < to_max)
         *to++ = from[*offset++];
     } else {
       // Currently that special case is the only case that's ever encountered.
       NOTREACHED();
       uint8* from = reinterpret_cast<uint8*>(backing_store_->data()) +
           (y * backing_store_->stride());
       uint8* to = reinterpret_cast<uint8*>(scaled_backing_store_->data()) +
           (y_scaled * scaled_backing_store_->stride()) +
           (r_scaled_left * kBytesPerPixel);
       for (int x_sc = r_scaled_left; x_sc < r_scaled_right; x_sc++) {
         int x = screen_x_to_host_x_[x_sc];
         memcpy(to, from + (x * kBytesPerPixel), kBytesPerPixel);
         to += kBytesPerPixel;
       }
     }
   }
-  return gfx::Rect(r_scaled_left, r_scaled_top, r_scaled_right - r_scaled_left,
-                   r_scaled_bottom - r_scaled_top);
+  return pp::Rect(r_scaled_left, r_scaled_top, r_scaled_right - r_scaled_left,
+                  r_scaled_bottom - r_scaled_top);
 }
 
-void PepperView::BlankRect(pp::ImageData& image_data, const gfx::Rect& rect) {
+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);
   }
 }
 
 void PepperView::SetSolidFill(uint32 color) {
   DCHECK(CurrentlyOnPluginThread());
@@ skipping 54 matching lines @@
     return;
 
   host_width_ = width;
   host_height_ = height;
 
   ResizeInternals();
 
   instance_->GetScriptableObject()->SetDesktopSize(host_width_, host_height_);
 }
 
-gfx::Point PepperView::ConvertScreenToHost(const gfx::Point& p) const {
+pp::Point PepperView::ConvertScreenToHost(const pp::Point& p) const {
   DCHECK(CurrentlyOnPluginThread());
 
   int x = static_cast<int>(p.x() / screen_scale_);
   x = std::min(x, host_width_ - 1);
   x = std::max(x, 0);
   int y = static_cast<int>(p.y() / screen_scale_);
   y = std::min(y, host_height_ - 1);
   y = std::max(y, 0);
-  return gfx::Point(x, y);
+  return pp::Point(x, y);
 }
 
-gfx::Point PepperView::ConvertHostToScreen(const gfx::Point& p) const {
-  return gfx::Point(static_cast<int>(p.x() * screen_scale_),
+pp::Point PepperView::ConvertHostToScreen(const pp::Point& p) const {
+  return pp::Point(static_cast<int>(p.x() * screen_scale_),
                     static_cast<int>(p.y() * screen_scale_));
 }
 
 void PepperView::SetScreenScale(double screen_scale) {
   if (screen_scale == screen_scale_)
     return;
   screen_scale_ = screen_scale;
   ResizeInternals();
   RefreshPaint();
 }
 
 void PepperView::RefreshPaint() {
   if (DoScaling()) {
     // Render from the whole backing store, to the scaled backing store, at the
     // current scale.
-    gfx::Rect updated_rect = UpdateScaledBackingStore(gfx::Rect(
+    pp::Rect updated_rect = UpdateScaledBackingStore(pp::Rect(
         host_width_, host_height_));
     // If the scale has just decreased, then there is stale raster data
     // to the right of, and below, the scaled copy of the host screen that's
     // just been rendered into the scaled backing store.
     // So blank out everything to the east of that copy...
-    BlankRect(*scaled_backing_store_, gfx::Rect(
+    BlankRect(*scaled_backing_store_, pp::Rect(
         updated_rect.right(), 0,
         scaled_backing_store_->size().width() - updated_rect.right(),
         updated_rect.bottom()));
     // ...and everything to the south and south-east.
-    BlankRect(*scaled_backing_store_, gfx::Rect(
+    BlankRect(*scaled_backing_store_, pp::Rect(
         0, updated_rect.bottom(), scaled_backing_store_->size().width(),
         scaled_backing_store_->size().height() - updated_rect.bottom()));
     graphics2d_.PaintImageData(*scaled_backing_store_.get(), pp::Point(0, 0),
                                pp::Rect(scaled_backing_store_->size()));
     graphics2d_.Flush(TaskToCompletionCallback(
         task_factory_.NewRunnableMethod(&PepperView::OnRefreshPaintDone)));
   } else {
     graphics2d_.PaintImageData(*backing_store_.get(), pp::Point(0, 0),
                                pp::Rect(backing_store_->size()));
     graphics2d_.Flush(TaskToCompletionCallback(
@@ skipping 38 matching lines @@
           << "Not enough memory for scaled backing store.";
     }
   } else {
     scaled_backing_store_.reset();
   }
 
   // Cache the horizontal component of the map from client screen co-ordinates
   // to host screen co-ordinates.
   screen_x_to_host_x_.reset(new int[client_width_]);
   for (int x = 0; x < client_width_; x++)
-    screen_x_to_host_x_[x] = ConvertScreenToHost(gfx::Point(x, 0)).x();
+    screen_x_to_host_x_[x] = ConvertScreenToHost(pp::Point(x, 0)).x();
 }
 
 bool PepperView::DoScaling() const {
   return (screen_scale_ != 1.0);
 }
 
 void PepperView::SetScreenSize(int width, int height) {
   DCHECK(CurrentlyOnPluginThread());
 
   client_width_ = width;
@@ skipping 69 matching lines @@
   instance_->GetStats()->video_paint_ms()->Record(
       (base::Time::Now() - paint_start).InMilliseconds());
   return;
 }
 
 void PepperView::OnRefreshPaintDone() {
   DCHECK(CurrentlyOnPluginThread());
 }
 
 }  // namespace remoting