Implement cc::FilterOperation StructTraits

cc/ipc/struct_traits_unittest.cc

 // Copyright 2016 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 "base/message_loop/message_loop.h"
 #include "cc/input/selection.h"
 #include "cc/ipc/traits_test_service.mojom.h"
 #include "cc/quads/render_pass_id.h"
 #include "mojo/public/cpp/bindings/binding_set.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/skia/include/core/SkString.h"
+#include "third_party/skia/include/effects/SkDropShadowImageFilter.h"
 
 namespace cc {
 
 namespace {
 
 class StructTraitsTest : public testing::Test, public mojom::TraitsTestService {
  public:
   StructTraitsTest() {}
 
  protected:
   mojom::TraitsTestServicePtr GetTraitsTestProxy() {
     return traits_test_bindings_.CreateInterfacePtrAndBind(this);
   }
 
  private:
   // TraitsTestService:
   void EchoBeginFrameArgs(const BeginFrameArgs& b,
                           const EchoBeginFrameArgsCallback& callback) override {
     callback.Run(b);
   }
 
   void EchoCompositorFrameMetadata(
       const CompositorFrameMetadata& c,
       const EchoCompositorFrameMetadataCallback& callback) override {
     callback.Run(c);
   }
 
+  void EchoFilterOperation(
+      const FilterOperation& f,
+      const EchoFilterOperationCallback& callback) override {
+    callback.Run(f);
+  }
+
   void EchoRenderPassId(const RenderPassId& r,
                         const EchoRenderPassIdCallback& callback) override {
     callback.Run(r);
   }
 
   void EchoReturnedResource(
       const ReturnedResource& r,
       const EchoReturnedResourceCallback& callback) override {
     callback.Run(r);
   }
@@ skipping 123 matching lines @@
       &component));
   EXPECT_EQ(7331, component.sequence_number);
   EXPECT_EQ(satisfies_sequences.size(), output.satisfies_sequences.size());
   for (uint32_t i = 0; i < satisfies_sequences.size(); ++i)
     EXPECT_EQ(satisfies_sequences[i], output.satisfies_sequences[i]);
   EXPECT_EQ(referenced_surfaces.size(), output.referenced_surfaces.size());
   for (uint32_t i = 0; i < referenced_surfaces.size(); ++i)
     EXPECT_EQ(referenced_surfaces[i], output.referenced_surfaces[i]);
 }
 
+TEST_F(StructTraitsTest, FilterOperation) {
+  const FilterOperation inputs[] = {
+      FilterOperation::CreateBlurFilter(20),
+      FilterOperation::CreateDropShadowFilter(gfx::Point(4, 4), 4.0f,
+                                              SkColorSetARGB(255, 40, 0, 0)),
+      FilterOperation::CreateReferenceFilter(SkDropShadowImageFilter::Make(
+          SkIntToScalar(3), SkIntToScalar(8), SkIntToScalar(4),
+          SkIntToScalar(9), SK_ColorBLACK,
+          SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode,
+          nullptr))};
+  mojom::TraitsTestServicePtr proxy = GetTraitsTestProxy();
+  for (const auto& input : inputs) {
+    FilterOperation output;
+    proxy->EchoFilterOperation(input, &output);
+    EXPECT_EQ(input.type(), output.type());
+    switch (input.type()) {
+      case FilterOperation::GRAYSCALE:
+      case FilterOperation::SEPIA:
+      case FilterOperation::SATURATE:
+      case FilterOperation::HUE_ROTATE:
+      case FilterOperation::INVERT:
+      case FilterOperation::BRIGHTNESS:
+      case FilterOperation::SATURATING_BRIGHTNESS:
+      case FilterOperation::CONTRAST:
+      case FilterOperation::OPACITY:
+      case FilterOperation::BLUR:
+        EXPECT_EQ(input.amount(), output.amount());
+        continue;

[yzshen1, 2016/06/08 16:25:16]

It seems more common to use "break;" here.

[Fady Samuel, 2016/06/08 17:04:19]

Done.

+      case FilterOperation::DROP_SHADOW:
+        EXPECT_EQ(input.amount(), output.amount());
+        EXPECT_EQ(input.drop_shadow_offset(), output.drop_shadow_offset());
+        EXPECT_EQ(input.drop_shadow_color(), output.drop_shadow_color());
+        continue;
+      case FilterOperation::COLOR_MATRIX:
+        EXPECT_EQ(0, memcmp(input.matrix(), output.matrix(), 20));
+        continue;
+      case FilterOperation::ZOOM:
+        EXPECT_EQ(input.amount(), output.amount());
+        EXPECT_EQ(input.zoom_inset(), output.zoom_inset());
+        continue;
+      case FilterOperation::REFERENCE: {
+        SkString input_str;
+        input.image_filter()->toString(&input_str);
+        SkString output_str;
+        output.image_filter()->toString(&output_str);
+        EXPECT_EQ(input_str, output_str);
+        continue;
+      }
+      case FilterOperation::ALPHA_THRESHOLD:
+        NOTREACHED();
+        continue;
+    }
+  }
+}
+
 TEST_F(StructTraitsTest, RenderPassId) {
   const int layer_id = 1337;
   const uint32_t index = 0xdeadbeef;
   RenderPassId input(layer_id, index);
   mojom::TraitsTestServicePtr proxy = GetTraitsTestProxy();
   RenderPassId output;
   proxy->EchoRenderPassId(input, &output);
   EXPECT_EQ(layer_id, output.layer_id);
   EXPECT_EQ(index, output.index);
 }
@@ skipping 137 matching lines @@
   EXPECT_EQ(mailbox_holder.sync_token, output.mailbox_holder.sync_token);
   EXPECT_EQ(mailbox_holder.texture_target,
             output.mailbox_holder.texture_target);
   EXPECT_EQ(read_lock_fences_enabled, output.read_lock_fences_enabled);
   EXPECT_EQ(is_software, output.is_software);
   EXPECT_EQ(gpu_memory_buffer_id, output.gpu_memory_buffer_id.id);
   EXPECT_EQ(is_overlay_candidate, output.is_overlay_candidate);
 }
 
 }  // namespace cc