Added SkImageFilter serialization

content/common/cc_messages.cc

 // Copyright (c) 2012 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 "content/common/cc_messages.h"
 
+#include "base/command_line.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/filter_operations.h"
 #include "content/public/common/common_param_traits.h"
+#include "content/public/common/content_switches.h"
+#include "third_party/skia/src/core/SkOrderedReadBuffer.h"
+#include "third_party/skia/src/core/SkOrderedWriteBuffer.h"
 #include "ui/gfx/transform.h"
 
 namespace IPC {
 
 void ParamTraits<cc::FilterOperation>::Write(
     Message* m, const param_type& p) {
   WriteParam(m, p.type());
   switch (p.type()) {
     case cc::FilterOperation::GRAYSCALE:
     case cc::FilterOperation::SEPIA:
@@ skipping 158 matching lines @@
     const param_type& p, std::string* l) {
   l->append("(");
   for (std::size_t i = 0; i < p.size(); ++i) {
     if (i)
       l->append(", ");
     LogParam(p.at(i), l);
   }
   l->append(")");
 }
 
+void ParamTraits<skia::RefPtr<SkImageFilter> >::Write(
+    Message* m, const param_type& p) {
+  const CommandLine& command_line = *CommandLine::ForCurrentProcess();
+  if (!command_line.HasSwitch(switches::kAllowFiltersOverIPC))

[palmer, 2013/08/01 20:26:27]

For security purposes, this check should be done in the browser process, right?

[piman, 2013/08/01 21:25:28]

See my comments, I think it's ok, and preferable to not write the data that
won't be read, but the authority on the decision is definitely browser-side.

+    return;
+  SkImageFilter* filter = p.get();
+  if (filter) {
+    SkOrderedWriteBuffer buffer(1024);
+    buffer.setFlags(SkOrderedWriteBuffer::kCrossProcess_Flag);
+    buffer.writeFlattenable(filter);
+    buffer.writeToMemory(m->BeginWriteData(buffer.bytesWritten()));
+  } else {
+    m->WriteData(0, 0);
+  }
+}
+
+bool ParamTraits<skia::RefPtr<SkImageFilter> >::Read(
+    const Message* m, PickleIterator* iter, param_type* r) {
+  const CommandLine& command_line = *CommandLine::ForCurrentProcess();
+  if (!command_line.HasSwitch(switches::kAllowFiltersOverIPC)) {

[palmer, 2013/08/01 20:26:27]

Same thing here.

[piman, 2013/08/01 21:25:28]

FYI, that side is the one that runs in the browser process (or, more generally
future-wise, the "privileged" process).

[palmer, 2013/08/06 17:48:31]

As I (think I) understand it now: in Write, the unprivileged process optimizes
by not sending the data unless it thinks it can. In Read, the privileged process
actually enforces the policy. Is that right?

I had a feeling that might be what was going on, and it makes sense. I felt a
need to make sure since this is common code; usually, I look for privileged code
in the browser and unprivileged code in the renderer. But, this is OK.

+    r->clear();
+    return true;
+  }
+  const char* data = 0;
+  int length = 0;
+  if (!m->ReadData(iter, &data, &length))
+    return false;
+  if (length > 0) {
+    SkOrderedReadBuffer buffer(data, length);
+    *r = skia::AdoptRef(buffer.readFlattenableT<SkImageFilter>());
+  } else {
+    r->clear();
+  }
+  return true;
+}
+
+void ParamTraits<skia::RefPtr<SkImageFilter> >::Log(
+    const param_type& p, std::string* l) {
+  l->append("(");
+  LogParam(p.get() ? p->countInputs() : 0, l);
+  l->append(")");
+}
+
 void ParamTraits<gfx::Transform>::Write(
     Message* m, const param_type& p) {
   WriteParam(m, p.matrix().getDouble(0, 0));
   WriteParam(m, p.matrix().getDouble(1, 0));
   WriteParam(m, p.matrix().getDouble(2, 0));
   WriteParam(m, p.matrix().getDouble(3, 0));
   WriteParam(m, p.matrix().getDouble(0, 1));
   WriteParam(m, p.matrix().getDouble(1, 1));
   WriteParam(m, p.matrix().getDouble(2, 1));
   WriteParam(m, p.matrix().getDouble(3, 1));
@@ skipping 509 matching lines @@
   l->append(", [");
   for (size_t i = 0; i < p.render_pass_list.size(); ++i) {
     if (i)
       l->append(", ");
     LogParam(*p.render_pass_list[i], l);
   }
   l->append("])");
 }
 
 }  // namespace IPC