Use webrtc::MouseCursorMonitor for cursor shapes

remoting/host/chromoting_param_traits.cc

Index: remoting/host/chromoting_param_traits.cc
diff --git a/remoting/host/chromoting_param_traits.cc b/remoting/host/chromoting_param_traits.cc
index 8b10a7f764308bca6d501b4399a94be2f7891ea4..456040c67480adc5d17fec75e4dbcc01afbb0fc4 100644
--- a/remoting/host/chromoting_param_traits.cc
+++ b/remoting/host/chromoting_param_traits.cc
@@ -5,6 +5,7 @@
 #include "remoting/host/chromoting_param_traits.h"
 
 #include "base/strings/stringprintf.h"
+#include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
 
 namespace IPC {
 
@@ -88,6 +89,73 @@ void ParamTraits<webrtc::DesktopRect>::Log(const webrtc::DesktopRect& p,
 }
 
 // static
+void ParamTraits<scoped_ptr<webrtc::MouseCursor>>::Write(

[Cris Neckar, 2013/12/11 20:59:40]

This just reads as strange. I would get rid of the scoped_ptr wrapper. Why can't
you just create a ParamTraits for MouseCursor that creates a new instance using
the data off the wire?

[Sergey Ulanov, 2013/12/11 21:16:37]

webrtc::MouseCursor is immutable and it doesn't have default constructor, which
is required by ParamTraits<>. The problem is that Read() gets a pointer to an
"empty" instance of an object that and is supposed to fill the data, which
doesn't work for immutable objects.

[Cris Neckar, 2013/12/11 21:47:12]

What is the scope of this object exactly? I assume this will be deleted when the
message handler returns (or even when the message is dispatched)? This means you
are going to have to release ownership at some point prior to this for it to
even work?

Could you just create a wrapper class around MouseCursor which will be created
in the pickle macros and then it can call the constructor for MouseCursor within
it's param traits?

I talked to tsepez@ about this and we are pretty scared of introducing object
lifetime issues if we start scoping things to messages. I'd really like to not
set this precedent and potentially have others copy this code in the future.

[dcaiafa, 2014/01/23 19:15:39]

MouseCursor is now mutable so I removed the hack.

On 2013/12/11 21:47:12, Cris Neckar wrote:

+    Message* m,
+    const scoped_ptr<webrtc::MouseCursor>& p) {
+  CHECK(p.get());
+
+  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<scoped_ptr<webrtc::MouseCursor>>::Read(
+    const Message* m,
+    PickleIterator* iter,
+    scoped_ptr<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;
+
+  webrtc::BasicDesktopFrame* image = new webrtc::BasicDesktopFrame(size);
+  memcpy(image->data(), data, data_length);
+  r->reset(new webrtc::MouseCursor(image, hotspot));
+  return true;
+}
+
+// static
+void ParamTraits<scoped_ptr<webrtc::MouseCursor>>::Log(
+    const scoped_ptr<webrtc::MouseCursor>& p,
+    std::string* l) {
+  CHECK(p.get());
+  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) {