Mojo C++ bindings: share DataView class between chromium and blink variants.

mojo/public/cpp/bindings/tests/struct_traits_unittest.cc

 // Copyright 2015 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/bind.h"
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "mojo/public/cpp/bindings/binding_set.h"
@@ skipping 52 matching lines @@
   // mojo::test::RectService:
   void AddRect(const RectChromium& r) override {
     if (r.GetArea() > largest_rect_.GetArea())
       largest_rect_ = r;
   }
 
   void GetLargestRect(const GetLargestRectCallback& callback) override {
     callback.Run(largest_rect_);
   }
 
+  void PassSharedRect(const SharedRect& r,
+                      const PassSharedRectCallback& callback) override {
+    callback.Run(r);
+  }
+
  private:
   RectChromium largest_rect_;
 };
 
 // This implements the generated Blink variant of RectService.
 class BlinkRectServiceImpl : public blink::RectService {
  public:
   BlinkRectServiceImpl() {}
 
   // mojo::test::blink::RectService:
   void AddRect(const RectBlink& r) override {
     if (r.computeArea() > largest_rect_.computeArea()) {
       largest_rect_.setX(r.x());
       largest_rect_.setY(r.y());
       largest_rect_.setWidth(r.width());
       largest_rect_.setHeight(r.height());
     }
   }
 
   void GetLargestRect(const GetLargestRectCallback& callback) override {
     callback.Run(largest_rect_);
   }
 
+  void PassSharedRect(const SharedRect& r,
+                      const PassSharedRectCallback& callback) override {
+    callback.Run(r);
+  }
+
  private:
   RectBlink largest_rect_;
 };
 
 // A test which runs both Chromium and Blink implementations of a RectService.
 class StructTraitsTest : public testing::Test,
                          public TraitsTestService {
  public:
   StructTraitsTest() {}
 
@@ skipping 87 matching lines @@
   RectServicePtr chromium_proxy;
   BindToChromiumService(GetProxy(&chromium_proxy));
   {
     base::RunLoop loop;
     chromium_proxy->AddRect(RectChromium(1, 1, 4, 5));
     chromium_proxy->AddRect(RectChromium(-1, -1, 2, 2));
     chromium_proxy->GetLargestRect(
         ExpectResult(RectChromium(1, 1, 4, 5), loop.QuitClosure()));
     loop.Run();
   }
+  {
+    base::RunLoop loop;
+    chromium_proxy->PassSharedRect(
+        {1, 2, 3, 4},
+        ExpectResult(SharedRect({1, 2, 3, 4}), loop.QuitClosure()));
+    loop.Run();
+  }
 }
 
 TEST_F(StructTraitsTest, ChromiumToBlinkService) {
   RectServicePtr chromium_proxy;
   BindToBlinkService(GetProxy(&chromium_proxy));
   {
     base::RunLoop loop;
     chromium_proxy->AddRect(RectChromium(1, 1, 4, 5));
     chromium_proxy->AddRect(RectChromium(2, 2, 5, 5));
     chromium_proxy->GetLargestRect(
         ExpectResult(RectChromium(2, 2, 5, 5), loop.QuitClosure()));
     loop.Run();
   }
+  {
+    base::RunLoop loop;
+    chromium_proxy->PassSharedRect(
+        {1, 2, 3, 4},
+        ExpectResult(SharedRect({1, 2, 3, 4}), loop.QuitClosure()));
+    loop.Run();
+  }
   // The Blink service should drop our connection because RectBlink's
   // deserializer rejects negative origins.
   {
     base::RunLoop loop;
     ExpectError(&chromium_proxy, loop.QuitClosure());
     chromium_proxy->AddRect(RectChromium(-1, -1, 2, 2));
     chromium_proxy->GetLargestRect(
         Fail<RectChromium>("The pipe should have been closed."));
     loop.Run();
   }
 }
 
 TEST_F(StructTraitsTest, BlinkProxyToBlinkService) {
   blink::RectServicePtr blink_proxy;
   BindToBlinkService(GetProxy(&blink_proxy));
   {
     base::RunLoop loop;
     blink_proxy->AddRect(RectBlink(1, 1, 4, 5));
     blink_proxy->AddRect(RectBlink(10, 10, 20, 20));
     blink_proxy->GetLargestRect(
         ExpectResult(RectBlink(10, 10, 20, 20), loop.QuitClosure()));
     loop.Run();
   }
+  {
+    base::RunLoop loop;
+    blink_proxy->PassSharedRect(
+        {4, 3, 2, 1},
+        ExpectResult(SharedRect({4, 3, 2, 1}), loop.QuitClosure()));
+    loop.Run();
+  }
 }
 
 TEST_F(StructTraitsTest, BlinkProxyToChromiumService) {
   blink::RectServicePtr blink_proxy;
   BindToChromiumService(GetProxy(&blink_proxy));
   {
     base::RunLoop loop;
     blink_proxy->AddRect(RectBlink(1, 1, 4, 5));
     blink_proxy->AddRect(RectBlink(10, 10, 2, 2));
     blink_proxy->GetLargestRect(
         ExpectResult(RectBlink(1, 1, 4, 5), loop.QuitClosure()));
     loop.Run();
   }
+  {
+    base::RunLoop loop;
+    blink_proxy->PassSharedRect(
+        {4, 3, 2, 1},
+        ExpectResult(SharedRect({4, 3, 2, 1}), loop.QuitClosure()));
+    loop.Run();
+  }
 }
 
 void ExpectStructWithTraits(const StructWithTraitsImpl& expected,
                             const base::Closure& closure,
                             const StructWithTraitsImpl& passed) {
   EXPECT_EQ(expected.get_enum(), passed.get_enum());
   EXPECT_EQ(expected.get_bool(), passed.get_bool());
   EXPECT_EQ(expected.get_uint32(), passed.get_uint32());
   EXPECT_EQ(expected.get_uint64(), passed.get_uint64());
   EXPECT_EQ(expected.get_string(), passed.get_string());
@@ skipping 243 matching lines @@
               quit_closure.Run();
 
             },
             loop.QuitClosure()));
     loop.Run();
   }
 }
 
 }  // namespace test
 }  // namespace mojo