Mojo C++ Bindings: fix mojom::Foo::Deserialize() for component build.

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

 // Copyright 2014 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 <stddef.h>
 #include <stdint.h>
 #include <string.h>
 #include <utility>
 
 #include "mojo/public/cpp/bindings/lib/fixed_buffer.h"
 #include "mojo/public/cpp/system/message_pipe.h"
+#include "mojo/public/interfaces/bindings/tests/test_export2.mojom.h"
 #include "mojo/public/interfaces/bindings/tests/test_structs.mojom.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace test {
 namespace {
 
 RectPtr MakeRect(int32_t factor = 1) {
   return Rect::New(1 * factor, 2 * factor, 10 * factor, 20 * factor);
 }
@@ skipping 406 matching lines @@
 
 TEST_F(StructTest, Serialization_PublicAPI) {
   {
     // A null struct pointer.
     RectPtr null_struct;
     auto data = Rect::Serialize(&null_struct);
     EXPECT_TRUE(data.empty());
 
     // Initialize it to non-null.
     RectPtr output(Rect::New());
-    ASSERT_TRUE(Rect::Deserialize(std::move(data), &output));
+    ASSERT_TRUE(Rect::Deserialize(data, &output));
     EXPECT_TRUE(output.is_null());
   }
 
   {
     // A struct with no fields.
     EmptyStructPtr empty_struct(EmptyStruct::New());
     auto data = EmptyStruct::Serialize(&empty_struct);
     EXPECT_FALSE(data.empty());
 
     EmptyStructPtr output;
-    ASSERT_TRUE(EmptyStruct::Deserialize(std::move(data), &output));
+    ASSERT_TRUE(EmptyStruct::Deserialize(data, &output));
     EXPECT_FALSE(output.is_null());
   }
 
   {
     // A simple struct.
     RectPtr rect = MakeRect();
     RectPtr cloned_rect = rect.Clone();
     auto data = Rect::Serialize(&rect);
 
     RectPtr output;
-    ASSERT_TRUE(Rect::Deserialize(std::move(data), &output));
+    ASSERT_TRUE(Rect::Deserialize(data, &output));
     EXPECT_TRUE(output.Equals(cloned_rect));
   }
 
   {
     // A struct containing other objects.
     std::vector<RectPtr> rects;
     for (size_t i = 0; i < 3; ++i)
       rects.push_back(MakeRect(static_cast<int32_t>(i) + 1));
     NamedRegionPtr region(
         NamedRegion::New(std::string("region"), std::move(rects)));
 
     NamedRegionPtr cloned_region = region.Clone();
     auto data = NamedRegion::Serialize(&region);
 
     // Make sure that the serialized result gets pointers encoded properly.
     auto cloned_data = data;
     NamedRegionPtr output;
-    ASSERT_TRUE(NamedRegion::Deserialize(std::move(cloned_data), &output));
+    ASSERT_TRUE(NamedRegion::Deserialize(cloned_data, &output));
     EXPECT_TRUE(output.Equals(cloned_region));
   }
 
   {
     // Deserialization failure.
     RectPtr rect = MakeRect();
     auto data = Rect::Serialize(&rect);
 
     NamedRegionPtr output;
-    EXPECT_FALSE(NamedRegion::Deserialize(std::move(data), &output));
+    EXPECT_FALSE(NamedRegion::Deserialize(data, &output));
+  }
+
+  {
+    // A struct from another component.
+    auto pair = test_export2::StringPair::New("hello", "world");
+    auto data = test_export2::StringPair::Serialize(&pair);
+
+    test_export2::StringPairPtr output;
+    ASSERT_TRUE(test_export2::StringPair::Deserialize(data, &output));
+    EXPECT_TRUE(output.Equals(pair));
   }
 }
 
 TEST_F(StructTest, VersionedStructConstructor) {
   auto reordered = ReorderedStruct::New(123, 456, 789);
   EXPECT_EQ(123, reordered->a);
   EXPECT_EQ(456, reordered->b);
   EXPECT_EQ(789, reordered->c);
 
   reordered = ReorderedStruct::New(123, 456);
   EXPECT_EQ(123, reordered->a);
   EXPECT_EQ(6, reordered->b);
   EXPECT_EQ(456, reordered->c);
 
   reordered = ReorderedStruct::New(123);
   EXPECT_EQ(3, reordered->a);
   EXPECT_EQ(6, reordered->b);
   EXPECT_EQ(123, reordered->c);
 
   reordered = ReorderedStruct::New();
   EXPECT_EQ(3, reordered->a);
   EXPECT_EQ(6, reordered->b);
   EXPECT_EQ(1, reordered->c);
 }
 
 }  // namespace test
 }  // namespace mojo