Mojo C++ bindings: add a new mode to generator to use native STL/WTF types

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 <stdint.h>
 #include <utility>
 
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
 #include "mojo/public/cpp/test_support/test_utils.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";
 
 void RecordString(std::string* storage,
                   const base::Closure& closure,
-                  String str) {
-  *storage = str.PassStorage();
+                  const std::string& str) {
+  *storage = str;
   closure.Run();
 }
 
-base::Callback<void(mojo::String)> MakeStringRecorder(
+base::Callback<void(const std::string&)> MakeStringRecorder(
     std::string* storage,
     const base::Closure& closure) {
   return base::Bind(&RecordString, storage, closure);
 }
 
 class ImportedInterfaceImpl : public imported::ImportedInterface {
  public:
   ImportedInterfaceImpl(
       InterfaceRequest<imported::ImportedInterface> request,
       const base::Closure& closure)
@@ skipping 10 matching lines @@
   static int do_something_count_;
   Binding<ImportedInterface> binding_;
   base::Closure closure_;
 };
 int ImportedInterfaceImpl::do_something_count_ = 0;
 
 class SampleNamedObjectImpl : public sample::NamedObject {
  public:
   explicit SampleNamedObjectImpl(InterfaceRequest<sample::NamedObject> request)
       : binding_(this, std::move(request)) {}
-  void SetName(const mojo::String& name) override { name_ = name; }
+  void SetName(const std::string& name) override { name_ = name; }
 
   void GetName(const GetNameCallback& callback) override {
     callback.Run(name_);
   }
 
  private:
   std::string name_;
   StrongBinding<sample::NamedObject> binding_;
 };
 
@@ skipping 88 matching lines @@
   void PumpMessages() { base::RunLoop().RunUntilIdle(); }
 
  private:
   base::MessageLoop loop_;
 };
 
 void DoStuff(bool* got_response,
              std::string* got_text_reply,
              const base::Closure& closure,
              sample::ResponsePtr response,
-             String text_reply) {
+             const std::string& text_reply) {
   *got_text_reply = text_reply;
 
   if (response->pipe.is_valid()) {
     std::string text2;
     EXPECT_TRUE(ReadTextMessage(response->pipe.get(), &text2));
 
     // Ensure that simply accessing response.pipe does not close it.
     EXPECT_TRUE(response->pipe.is_valid());
 
     EXPECT_EQ(std::string(kText2), text2);
 
     // Do some more tests of handle passing:
     ScopedMessagePipeHandle p = std::move(response->pipe);
     EXPECT_TRUE(p.is_valid());
     EXPECT_FALSE(response->pipe.is_valid());
   }
 
   *got_response = true;
   closure.Run();
 }
 
 void DoStuff2(bool* got_response,
-             std::string* got_text_reply,
-             const base::Closure& closure,
-             String text_reply) {
+              std::string* got_text_reply,
+              const base::Closure& closure,
+              const std::string& text_reply) {
   *got_response = true;
   *got_text_reply = text_reply;
   closure.Run();
 }
 
 TEST_F(HandlePassingTest, Basic) {
   sample::FactoryPtr factory;
   SampleFactoryImpl factory_impl(GetProxy(&factory));
 
   MessagePipe pipe0;
@@ skipping 91 matching lines @@
 TEST_F(HandlePassingTest, PipesAreClosed) {
   sample::FactoryPtr factory;
   SampleFactoryImpl factory_impl(GetProxy(&factory));
 
   MessagePipe extra_pipe;
 
   MojoHandle handle0_value = extra_pipe.handle0.get().value();
   MojoHandle handle1_value = extra_pipe.handle1.get().value();
 
   {
-    Array<ScopedMessagePipeHandle> pipes(2);
+    std::vector<ScopedMessagePipeHandle> pipes(2);
     pipes[0] = std::move(extra_pipe.handle0);
     pipes[1] = std::move(extra_pipe.handle1);
 
     sample::RequestPtr request(sample::Request::New());
     request->more_pipes = std::move(pipes);
 
     factory->DoStuff(std::move(request), ScopedMessagePipeHandle(),
                      sample::Factory::DoStuffCallback());
   }
 
@@ skipping 31 matching lines @@
   run_loop.Run();
   run_loop2.Run();
 
   EXPECT_EQ(std::string("object1"), name1);
   EXPECT_EQ(std::string("object2"), name2);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace mojo