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

mojo/public/cpp/bindings/tests/struct_traits_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 "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/rect_blink.h"
 #include "mojo/public/cpp/bindings/tests/rect_chromium.h"
 #include "mojo/public/cpp/bindings/tests/struct_with_traits_impl.h"
 #include "mojo/public/cpp/bindings/tests/variant_test_util.h"
 #include "mojo/public/interfaces/bindings/tests/struct_with_traits.mojom.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(const T& expected,
                     const base::Closure& callback,
@@ skipping 39 matching lines @@
 
   void GetLargestRect(const GetLargestRectCallback& callback) override {
     callback.Run(largest_rect_);
   }
 
  private:
   RectChromium largest_rect_;
 };
 
 // This implements the generated Blink variant of RectService.
-class BlinkRectServiceImpl : public wtf::RectService {
+class BlinkRectServiceImpl : public blink::RectService {
  public:
   BlinkRectServiceImpl() {}
 
-  // mojo::test::wtf::RectService:
+  // mojo::test::blink::RectService:
   void AddRect(const RectBlink& r) override {
     if (r.computeArea() > largest_rect_.computeArea()) {
       largest_rect_.setX(r.x());
       largest_rect_.setY(r.y());
       largest_rect_.setWidth(r.width());
       largest_rect_.setHeight(r.height());
     }
   }
 
   void GetLargestRect(const GetLargestRectCallback& callback) override {
     callback.Run(largest_rect_);
   }
 
  private:
   RectBlink largest_rect_;
 };
 
 // A test which runs both Chromium and Blink implementations of a RectService.
 class StructTraitsTest : public testing::Test,
                          public TraitsTestService {
  public:
   StructTraitsTest() {}
 
  protected:
   void BindToChromiumService(RectServiceRequest request) {
     chromium_bindings_.AddBinding(&chromium_service_, std::move(request));
   }
-  void BindToChromiumService(wtf::RectServiceRequest request) {
+  void BindToChromiumService(blink::RectServiceRequest request) {
     chromium_bindings_.AddBinding(
         &chromium_service_,
         ConvertInterfaceRequest<RectService>(std::move(request)));
   }
 
-  void BindToBlinkService(wtf::RectServiceRequest request) {
+  void BindToBlinkService(blink::RectServiceRequest request) {
     blink_bindings_.AddBinding(&blink_service_, std::move(request));
   }
   void BindToBlinkService(RectServiceRequest request) {
     blink_bindings_.AddBinding(
         &blink_service_,
-        ConvertInterfaceRequest<wtf::RectService>(std::move(request)));
+        ConvertInterfaceRequest<blink::RectService>(std::move(request)));
   }
 
   TraitsTestServicePtr GetTraitsTestProxy() {
     return traits_test_bindings_.CreateInterfacePtrAndBind(this);
   }
 
  private:
   // TraitsTestService:
   void PassStructWithTraits(
       const StructWithTraitsImpl& s,
       const PassStructWithTraitsCallback& callback) override {
     callback.Run(s);
   }
 
   base::MessageLoop loop_;
 
   ChromiumRectServiceImpl chromium_service_;
   BindingSet<RectService> chromium_bindings_;
 
   BlinkRectServiceImpl blink_service_;
-  BindingSet<wtf::RectService> blink_bindings_;
+  BindingSet<blink::RectService> blink_bindings_;
 
   BindingSet<TraitsTestService> traits_test_bindings_;
 };
 
 }  // namespace
 
 TEST_F(StructTraitsTest, ChromiumProxyToChromiumService) {
   RectServicePtr chromium_proxy;
   BindToChromiumService(GetProxy(&chromium_proxy));
   {
@@ skipping 23 matching lines @@
     base::RunLoop loop;
     ExpectError(&chromium_proxy, loop.QuitClosure());
     chromium_proxy->AddRect(RectChromium(-1, -1, 2, 2));
     chromium_proxy->GetLargestRect(
         Fail<RectChromium>("The pipe should have been closed."));
     loop.Run();
   }
 }
 
 TEST_F(StructTraitsTest, BlinkProxyToBlinkService) {
-  wtf::RectServicePtr blink_proxy;
+  blink::RectServicePtr blink_proxy;
   BindToBlinkService(GetProxy(&blink_proxy));
   {
     base::RunLoop loop;
     blink_proxy->AddRect(RectBlink(1, 1, 4, 5));
     blink_proxy->AddRect(RectBlink(10, 10, 20, 20));
     blink_proxy->GetLargestRect(
         ExpectResult(RectBlink(10, 10, 20, 20), loop.QuitClosure()));
     loop.Run();
   }
 }
 
 TEST_F(StructTraitsTest, BlinkProxyToChromiumService) {
-  wtf::RectServicePtr blink_proxy;
+  blink::RectServicePtr blink_proxy;
   BindToChromiumService(GetProxy(&blink_proxy));
   {
     base::RunLoop loop;
     blink_proxy->AddRect(RectBlink(1, 1, 4, 5));
     blink_proxy->AddRect(RectBlink(10, 10, 2, 2));
     blink_proxy->GetLargestRect(
         ExpectResult(RectBlink(1, 1, 4, 5), loop.QuitClosure()));
     loop.Run();
   }
 }
@@ skipping 14 matching lines @@
         EXPECT_EQ(input.get_uint32(), passed.get_uint32());
         EXPECT_EQ(input.get_uint64(), passed.get_uint64());
         EXPECT_EQ(input.get_string(), passed.get_string());
         loop.Quit();
       });
   loop.Run();
 }
 
 }  // namespace test
 }  // namespace mojo