Mojo: Add support for InterfacePtr as a struct member

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

 // Copyright 2013 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/environment/environment.h"
 #include "mojo/public/cpp/test_support/test_utils.h"
 #include "mojo/public/cpp/utility/run_loop.h"
 #include "mojo/public/interfaces/bindings/tests/sample_factory.mojom.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace test {
 namespace {
 
 const char kText1[] = "hello";
 const char kText2[] = "world";
 
 class StringRecorder {
  public:
   explicit StringRecorder(std::string* buf) : buf_(buf) {
   }
   void Run(const String& a) const {
     *buf_ = a.To<std::string>();
   }
  private:
   std::string* buf_;
 };
 
+class ImportedInterfaceImpl
+    : public InterfaceImpl<imported::ImportedInterface> {
+ public:
+  virtual void OnConnectionError() MOJO_OVERRIDE {
+    delete this;
+  }
+
+  virtual void DoSomething() MOJO_OVERRIDE {
+    do_something_count_++;
+  }
+
+  static int do_something_count() { return do_something_count_; }
+
+ private:
+  static int do_something_count_;
+};
+int ImportedInterfaceImpl::do_something_count_ = 0;
+
 class SampleNamedObjectImpl : public InterfaceImpl<sample::NamedObject> {
  public:
   virtual void OnConnectionError() MOJO_OVERRIDE {
     delete this;
   }
 
   virtual void SetName(const mojo::String& name) MOJO_OVERRIDE {
     name_ = name;
   }
 
@@ skipping 29 matching lines @@
     ScopedMessagePipeHandle pipe0;
     if (!text2.empty()) {
       CreateMessagePipe(NULL, &pipe0, &pipe1_);
       EXPECT_TRUE(WriteTextMessage(pipe1_.get(), text2));
     }
 
     sample::ResponsePtr response(sample::Response::New());
     response->x = 2;
     response->pipe = pipe0.Pass();
     client()->DidStuff(response.Pass(), text1);
+
+    if (request->obj.get())
+      request->obj->DoSomething();
   }
 
   virtual void DoStuff2(ScopedDataPipeConsumerHandle pipe) MOJO_OVERRIDE {
     // Read the data from the pipe, writing the response (as a string) to
     // DidStuff2().
     ASSERT_TRUE(pipe.is_valid());
     uint32_t data_size = 0;
     ASSERT_EQ(MOJO_RESULT_OK,
               ReadDataRaw(pipe.get(), NULL, &data_size,
                           MOJO_READ_DATA_FLAG_QUERY));
@@ skipping 99 matching lines @@
   factory_client.set_expected_text_reply(kText1);
 
   factory.set_client(&factory_client);
 
   MessagePipe pipe0;
   EXPECT_TRUE(WriteTextMessage(pipe0.handle1.get(), kText1));
 
   MessagePipe pipe1;
   EXPECT_TRUE(WriteTextMessage(pipe1.handle1.get(), kText2));
 
+  imported::ImportedInterfacePtr imported;
+  BindToProxy(new ImportedInterfaceImpl(), &imported);
+
   sample::RequestPtr request(sample::Request::New());
   request->x = 1;
   request->pipe = pipe1.handle0.Pass();
+  request->obj = imported.Pass();
   factory->DoStuff(request.Pass(), pipe0.handle0.Pass());
 
   EXPECT_FALSE(factory_client.got_response());
+  int count_before = ImportedInterfaceImpl::do_something_count();
 
   PumpMessages();
 
   EXPECT_TRUE(factory_client.got_response());
+  EXPECT_EQ(1, ImportedInterfaceImpl::do_something_count() - count_before);
 }
 
 TEST_F(HandlePassingTest, PassInvalid) {
   sample::FactoryPtr factory;
   BindToProxy(new SampleFactoryImpl(), &factory);
 
   SampleFactoryClientImpl factory_client;
   factory.set_client(&factory_client);
 
   sample::RequestPtr request(sample::Request::New());
@@ skipping 113 matching lines @@
 
   PumpMessages();  // Yield for results.
 
   EXPECT_EQ(std::string("object1"), name1);
   EXPECT_EQ(std::string("object2"), name2);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace mojo