Mojo C++ bindings: Generate InterfaceHandle<> instead of InterfacePtr<>.

mojo/public/cpp/bindings/tests/array_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 "mojo/public/cpp/bindings/array.h"
 #include "mojo/public/cpp/bindings/lib/array_internal.h"
 #include "mojo/public/cpp/bindings/lib/array_serialization.h"
 #include "mojo/public/cpp/bindings/lib/fixed_buffer.h"
 #include "mojo/public/cpp/bindings/tests/container_test_util.h"
 #include "mojo/public/cpp/bindings/tests/iterator_test_util.h"
@@ skipping 377 matching lines @@
   EXPECT_TRUE(array[3].is_valid());
 }
 
 TEST_F(ArrayTest, Serialization_StructWithArraysOfHandles) {
   StructWithHandles handles_struct;
   MessagePipe handle_pair_0;
 }
 
 // Test serializing and deserializing an Array<InterfacePtr>.
 TEST_F(ArrayTest, Serialization_ArrayOfInterfacePtr) {
-  auto iface_array = Array<TestInterfacePtr>::New(1);
+  auto iface_array = Array<mojo::InterfaceHandle<TestInterface>>::New(1);
   size_t size = GetSerializedSize_(iface_array);
   EXPECT_EQ(8U               // array header
                 + (8U * 1),  // Interface_Data * number of elements
             size);
 
   FixedBufferForTesting buf(size * 3);
   Array_Data<mojo::internal::Interface_Data>* output = nullptr;
 
   // 1.  Invalid InterfacePtr should fail serialization.
   ArrayValidateParams validate_non_nullable(1, false, nullptr);
   EXPECT_EQ(
       mojo::internal::ValidationError::UNEXPECTED_INVALID_HANDLE,
       SerializeArray_(&iface_array, &buf, &output, &validate_non_nullable));
-  EXPECT_FALSE(iface_array[0].is_bound());
+  EXPECT_FALSE(iface_array[0].is_valid());
 
   // 2.  Invalid InterfacePtr should pass if array elements are nullable.
   ArrayValidateParams validate_nullable(1, true, nullptr);
   EXPECT_EQ(mojo::internal::ValidationError::NONE,
             SerializeArray_(&iface_array, &buf, &output, &validate_nullable));
-  EXPECT_FALSE(iface_array[0].is_bound());
+  EXPECT_FALSE(iface_array[0].is_valid());
 
   // 3.  Should serialize successfully if InterfacePtr is valid.
   TestInterfacePtr iface_ptr;
   auto iface_req = GetProxy(&iface_ptr);
 
   iface_array[0] = iface_ptr.Pass();
-  EXPECT_TRUE(iface_array[0].is_bound());
+  EXPECT_TRUE(iface_array[0].is_valid());
 
   EXPECT_EQ(
       mojo::internal::ValidationError::NONE,
       SerializeArray_(&iface_array, &buf, &output, &validate_non_nullable));
-  EXPECT_FALSE(iface_array[0].is_bound());
+  EXPECT_FALSE(iface_array[0].is_valid());
 
   Deserialize_(output, &iface_array);
-  EXPECT_TRUE(iface_array[0].is_bound());
+  EXPECT_TRUE(iface_array[0].is_valid());
 }
 
 // Test serializing and deserializing a struct with an Array<> of another struct
 // which has an InterfacePtr.
 TEST_F(ArrayTest, Serialization_StructWithArrayOfInterfacePtr) {
   StructWithInterfaceArray struct_arr_iface;
   struct_arr_iface.structs_array = Array<StructWithInterfacePtr>::New(1);
   struct_arr_iface.nullable_structs_array =
       Array<StructWithInterfacePtr>::New(1);
 
@@ skipping 17 matching lines @@
             Serialize_(&struct_arr_iface, &buf, &struct_arr_iface_data));
 
   //  2. Adding in a struct with a valid InterfacePtr<> will let it serialize.
   TestInterfacePtr iface_ptr;
   auto iface_req = GetProxy(&iface_ptr);
 
   StructWithInterfacePtr iface_struct(StructWithInterface::New());
   iface_struct->iptr = iface_ptr.Pass();
 
   struct_arr_iface.structs_array[0] = iface_struct.Pass();
-  ASSERT_TRUE(struct_arr_iface.structs_array[0]->iptr.is_bound());
+  ASSERT_TRUE(struct_arr_iface.structs_array[0]->iptr.is_valid());
   EXPECT_EQ(mojo::internal::ValidationError::NONE,
             Serialize_(&struct_arr_iface, &buf, &struct_arr_iface_data));
 
-  EXPECT_FALSE(struct_arr_iface.structs_array[0]->iptr.is_bound());
+  EXPECT_FALSE(struct_arr_iface.structs_array[0]->iptr.is_valid());
 
   Deserialize_(struct_arr_iface_data, &struct_arr_iface);
-  EXPECT_TRUE(struct_arr_iface.structs_array[0]->iptr.is_bound());
+  EXPECT_TRUE(struct_arr_iface.structs_array[0]->iptr.is_valid());
 }
 
 // Test serializing and deserializing a struct with an Array<> of interface
 // requests.
 TEST_F(ArrayTest, Serialization_StructWithArrayOfIntefaceRequest) {
   StructWithInterfaceRequests struct_arr_iface_req;
   struct_arr_iface_req.req_array =
       Array<InterfaceRequest<TestInterface>>::New(1);
   struct_arr_iface_req.nullable_req_array =
       Array<InterfaceRequest<TestInterface>>::New(1);
@@ skipping 335 matching lines @@
     EXPECT_EQ(1, array3[1]->x);
     EXPECT_EQ(2, array3[1]->y);
     EXPECT_EQ(3, array3[1]->width);
     EXPECT_EQ(4, array3[1]->height);
   }
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace mojo