Add support for converting cc::FilterOperations into an SkImageFilter

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"
@@ skipping 26 matching lines @@
       WriteParam(m, p.drop_shadow_color());
       break;
     case cc::FilterOperation::COLOR_MATRIX:
       for (int i = 0; i < 20; ++i)
         WriteParam(m, p.matrix()[i]);
       break;
     case cc::FilterOperation::ZOOM:
       WriteParam(m, p.amount());
       WriteParam(m, p.zoom_inset());
       break;
+    case cc::FilterOperation::REFERENCE:
+      if (CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kAllowFiltersOverIPC))

[piman, 2013/09/09 23:29:15]

nit: we already test the flag in ParamTraits<SkImageFilter>, I think we don't
need to test it twice. Maybe we can just unconditionally WriteParam it, and on
the reader side, unconditionally ReadParam it, and fix it up to an empty filter
if it comes out NULL. WDYT?

[ajuma, 2013/09/10 21:17:58]

Done. In fact, we don't even need to do any special fix up if the filter comes
out NULL, since setting the FilterOperation's image filter to NULL effectively
makes it a no-op filter.

+        WriteParam(m, p.image_filter());
+      break;
   }
 }
 
 bool ParamTraits<cc::FilterOperation>::Read(
     const Message* m, PickleIterator* iter, param_type* r) {
   cc::FilterOperation::FilterType type;
   float amount;
   gfx::Point drop_shadow_offset;
   SkColor drop_shadow_color;
   SkScalar matrix[20];
@@ skipping 45 matching lines @@
     case cc::FilterOperation::ZOOM:
       if (ReadParam(m, iter, &amount) &&
           ReadParam(m, iter, &zoom_inset) &&
           amount >= 0.f &&
           zoom_inset >= 0) {
         r->set_amount(amount);
         r->set_zoom_inset(zoom_inset);
         success = true;
       }
       break;
+    case cc::FilterOperation::REFERENCE: {
+      if (CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kAllowFiltersOverIPC)) {
+        skia::RefPtr<SkImageFilter> filter;
+        if (!ReadParam(m, iter, &filter)) {
+          success = false;
+          break;
+        }
+        if (!filter) {
+          success = false;
+          break;
+        }
+        r->set_image_filter(filter);
+        success = true;
+        break;
+      }
+      // When reference filters cannot be serialized, just use a noop filter.
+      *r = cc::FilterOperation::CreateEmptyFilter();
+      success = true;
+      break;
+    }
   }
   return success;
 }
 
 void ParamTraits<cc::FilterOperation>::Log(
     const param_type& p, std::string* l) {
   l->append("(");
   LogParam(static_cast<unsigned>(p.type()), l);
   l->append(", ");
 
@@ skipping 22 matching lines @@
         if (i)
           l->append(", ");
         LogParam(p.matrix()[i], l);
       }
       break;
     case cc::FilterOperation::ZOOM:
       LogParam(p.amount(), l);
       l->append(", ");
       LogParam(p.zoom_inset(), l);
       break;
+    case cc::FilterOperation::REFERENCE:
+      if (CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kAllowFiltersOverIPC))
+        LogParam(p.image_filter(), l);
+      break;
   }
   l->append(")");
 }
 
 void ParamTraits<cc::FilterOperations>::Write(
     Message* m, const param_type& p) {
   WriteParam(m, p.size());
   for (std::size_t i = 0; i < p.size(); ++i) {
     WriteParam(m, p.at(i));
   }
@@ skipping 582 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