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))
+    return;

[piman, 2013/08/01 19:53:22]

As it is, this relies on the flag being identical on both sides of the IPC. It's
probably true in this case, but there's always crazy reasons why they may not
be. If they aren't, then the entire IPC gets confused and we'll fail badly.

Could we instead, make the writer side write empty filter if the flag isn't set,
and the reader side always read the data, but discard it (before parsing) if the
flag isn't set?

That way we fall back sanely (no filter) if either side doesn't have the flag.

[sugoi1, 2013/08/01 20:23:28]

Done.

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