Mojo: Change the blink variant from "wtf" to "blink".

mojo/public/cpp/bindings/tests/pickle_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 <string>
 
 #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"
 #include "mojo/public/cpp/bindings/interface_request.h"
 #include "mojo/public/cpp/bindings/tests/pickled_struct_blink.h"
 #include "mojo/public/cpp/bindings/tests/pickled_struct_chromium.h"
 #include "mojo/public/cpp/bindings/tests/variant_test_util.h"
-#include "mojo/public/interfaces/bindings/tests/test_native_types.mojom-wtf.h"
+#include "mojo/public/interfaces/bindings/tests/test_native_types.mojom-blink.h"
 #include "mojo/public/interfaces/bindings/tests/test_native_types.mojom.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace test {
 namespace {
 
 template <typename T>
 void DoExpectResult(int foo,
                     int bar,
@@ skipping 47 matching lines @@
     callback.Run(std::move(pickles));
   }
 
   void PassPickleArrays(Array<Array<PickledStructChromium>> pickle_arrays,
                         const PassPickleArraysCallback& callback) override {
     callback.Run(std::move(pickle_arrays));
   }
 };
 
 // This implements the generated Blink variant of PicklePasser.
-class BlinkPicklePasserImpl : public wtf::PicklePasser {
+class BlinkPicklePasserImpl : public blink::PicklePasser {
  public:
   BlinkPicklePasserImpl() {}
 
-  // mojo::test::wtf::PicklePasser:
+  // mojo::test::blink::PicklePasser:
   void PassPickle(const PickledStructBlink& pickle,
                   const PassPickleCallback& callback) override {
     callback.Run(pickle);
   }
 
   void PassPickleContainer(
-      wtf::PickleContainerPtr container,
+      blink::PickleContainerPtr container,
       const PassPickleContainerCallback& callback) override {
     callback.Run(std::move(container));
   }
 
   void PassPickles(WTFArray<PickledStructBlink> pickles,
                    const PassPicklesCallback& callback) override {
     callback.Run(std::move(pickles));
   }
 
   void PassPickleArrays(WTFArray<WTFArray<PickledStructBlink>> pickle_arrays,
@@ skipping 11 matching lines @@
   template <typename ProxyType = PicklePasser>
   InterfacePtr<ProxyType> ConnectToChromiumService() {
     InterfacePtr<ProxyType> proxy;
     InterfaceRequest<ProxyType> request = GetProxy(&proxy);
     chromium_bindings_.AddBinding(
         &chromium_service_,
         ConvertInterfaceRequest<PicklePasser>(std::move(request)));
     return proxy;
   }
 
-  template <typename ProxyType = wtf::PicklePasser>
+  template <typename ProxyType = blink::PicklePasser>
   InterfacePtr<ProxyType> ConnectToBlinkService() {
     InterfacePtr<ProxyType> proxy;
     InterfaceRequest<ProxyType> request = GetProxy(&proxy);
     blink_bindings_.AddBinding(
         &blink_service_,
-        ConvertInterfaceRequest<wtf::PicklePasser>(std::move(request)));
+        ConvertInterfaceRequest<blink::PicklePasser>(std::move(request)));
     return proxy;
   }
 
  private:
   base::MessageLoop loop_;
   ChromiumPicklePasserImpl chromium_service_;
   BindingSet<PicklePasser> chromium_bindings_;
   BlinkPicklePasserImpl blink_service_;
-  BindingSet<wtf::PicklePasser> blink_bindings_;
+  BindingSet<blink::PicklePasser> blink_bindings_;
 };
 
 }  // namespace
 
 TEST_F(PickleTest, ChromiumProxyToChromiumService) {
   auto chromium_proxy = ConnectToChromiumService();
   {
     base::RunLoop loop;
     chromium_proxy->PassPickle(
         PickledStructChromium(1, 2),
@@ skipping 42 matching lines @@
   {
     base::RunLoop loop;
     blink_proxy->PassPickle(
         PickledStructBlink(1, 1),
         ExpectResult(PickledStructBlink(1, 1), loop.QuitClosure()));
     loop.Run();
   }
 }
 
 TEST_F(PickleTest, BlinkProxyToChromiumService) {
-  auto blink_proxy = ConnectToChromiumService<wtf::PicklePasser>();
+  auto blink_proxy = ConnectToChromiumService<blink::PicklePasser>();
   {
     base::RunLoop loop;
     blink_proxy->PassPickle(
         PickledStructBlink(1, 1),
         ExpectResult(PickledStructBlink(1, 1), loop.QuitClosure()));
     loop.Run();
   }
 }
 
 TEST_F(PickleTest, PickleArray) {
@@ skipping 87 matching lines @@
                                  EXPECT_EQ(43, passed->pickle.bar());
                                  EXPECT_EQ(0, passed->pickle.baz());
                                  run_loop.Quit();
                                });
     run_loop.Run();
   }
 }
 
 }  // namespace test
 }  // namespace mojo