Use webrtc::MouseCursorMonitor for cursor shapes

remoting/host/chromoting_param_traits.cc

 // Copyright 2013 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/host/chromoting_param_traits.h"
 
 #include "base/strings/stringprintf.h"
+#include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
 
 namespace IPC {
 
 // static
 void ParamTraits<webrtc::DesktopVector>::Write(Message* m,
                                                const webrtc::DesktopVector& p) {
   m->WriteInt(p.x());
   m->WriteInt(p.y());
 }
 
@@ skipping 63 matching lines @@
 }
 
 // static
 void ParamTraits<webrtc::DesktopRect>::Log(const webrtc::DesktopRect& p,
                                            std::string* l) {
   l->append(base::StringPrintf("webrtc::DesktopRect(%d, %d, %d, %d)",
                                p.left(), p.top(), p.right(), p.bottom()));
 }
 
 // static
+void ParamTraits<webrtc::MouseCursor>::Write(
+    Message* m,
+    const webrtc::MouseCursor& p) {
+  ParamTraits<webrtc::DesktopSize>::Write(m, p.image()->size());
+
+  // Data is serialized in such a way that size is exactly width * height *
+  // |kBytesPerPixel|.
+  std::string data;
+  uint8_t* current_row = p.image()->data();
+  for (int y = 0; y < p.image()->size().height(); ++y) {
+    data.append(current_row,
+                current_row + p.image()->size().width() *
+                    webrtc::DesktopFrame::kBytesPerPixel);
+    current_row += p.image()->stride();
+  }
+  m->WriteData(reinterpret_cast<const char*>(p.image()->data()), data.size());
+
+  ParamTraits<webrtc::DesktopVector>::Write(m, p.hotspot());
+}
+
+// static
+bool ParamTraits<webrtc::MouseCursor>::Read(
+    const Message* m,
+    PickleIterator* iter,
+    webrtc::MouseCursor* r) {
+  webrtc::DesktopSize size;
+  if (!ParamTraits<webrtc::DesktopSize>::Read(m, iter, &size) ||
+      size.width() <= 0 || size.width() > (SHRT_MAX / 2) ||
+      size.height() <= 0 || size.height() > (SHRT_MAX / 2)) {
+    return false;
+  }
+
+  const int expected_length =
+      size.width() * size.height() * webrtc::DesktopFrame::kBytesPerPixel;
+
+  const char* data;
+  int data_length;
+  if (!m->ReadData(iter, &data, &data_length) ||
+      data_length != expected_length) {
+    return false;
+  }
+
+  webrtc::DesktopVector hotspot;
+  if (!ParamTraits<webrtc::DesktopVector>::Read(m, iter, &hotspot))
+    return false;

[Cris Neckar, 2014/01/23 20:16:32]

In the constructor for MouseCursor there is an assert that the hotspot is within
the image. Can you check this here please. Not sure what can go wrong if it is
outside the image bounds but seeing as there is and assert I assume it isn't
good.

[Wez, 2014/01/23 20:56:18]

In general it's valid to have a hotspot outside a cursor image; some clients may
not support that, but they should really adapt such cursors as necessary.

[Sergey Ulanov, 2014/01/23 21:32:14]

Neither the capturers nor the PPB_MouseCursor interface support hotspot outside
of the image, so webrtc::MessageCursor should never have hotspot outside the
bounds. In the same time I don't think accepting such cursor here will have any
negative effect.

+
+  webrtc::BasicDesktopFrame* image = new webrtc::BasicDesktopFrame(size);
+  memcpy(image->data(), data, data_length);
+
+  r->set_image(image);
+  r->set_hotspot(hotspot);
+  return true;
+}
+
+// static
+void ParamTraits<webrtc::MouseCursor>::Log(
+    const webrtc::MouseCursor& p,
+    std::string* l) {
+  l->append(base::StringPrintf(
+      "webrtc::DesktopRect{image(%d, %d), hotspot(%d, %d)}",
+      p.image()->size().width(), p.image()->size().height(),
+      p.hotspot().x(), p.hotspot().y()));
+}
+
+
+// static
 void ParamTraits<remoting::ScreenResolution>::Write(
     Message* m,
     const remoting::ScreenResolution& p) {
   ParamTraits<webrtc::DesktopSize>::Write(m, p.dimensions());
   ParamTraits<webrtc::DesktopVector>::Write(m, p.dpi());
 }
 
 // static
 bool ParamTraits<remoting::ScreenResolution>::Read(
     const Message* m,
@@ skipping 17 matching lines @@
 void ParamTraits<remoting::ScreenResolution>::Log(
     const remoting::ScreenResolution& p,
     std::string* l) {
   l->append(base::StringPrintf("webrtc::ScreenResolution(%d, %d, %d, %d)",
                                p.dimensions().width(), p.dimensions().height(),
                                p.dpi().x(), p.dpi().y()));
 }
 
 }  // namespace IPC