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<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) {
   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