Be explicit about namespace testing to not mix it with blink::testing

third_party/WebKit/Source/platform/graphics/ContiguousContainerTest.cpp

 // 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 "platform/graphics/ContiguousContainer.h"
 
 #include "platform/wtf/TypeTraits.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 62 matching lines @@
   auto& destructible = list.AllocateAndConstruct<MockDestructible>();
   EXPECT_EQ(&destructible, &list.First());
   EXPECT_CALL(destructible, Destruct());
 }
 
 TEST(ContiguousContainerTest, DestructorCalledOnceWhenClear) {
   ContiguousContainer<MockDestructible> list(sizeof(MockDestructible));
   auto& destructible = list.AllocateAndConstruct<MockDestructible>();
   EXPECT_EQ(&destructible, &list.First());
 
-  testing::MockFunction<void()> separator;
+  ::testing::MockFunction<void()> separator;
   {
-    testing::InSequence s;
+    ::testing::InSequence s;
     EXPECT_CALL(destructible, Destruct());
     EXPECT_CALL(separator, Call());
     EXPECT_CALL(destructible, Destruct()).Times(0);
   }
 
   list.Clear();
   separator.Call();
 }
 
 TEST(ContiguousContainerTest, DestructorCalledOnceWhenRemoveLast) {
   ContiguousContainer<MockDestructible> list(sizeof(MockDestructible));
   auto& destructible = list.AllocateAndConstruct<MockDestructible>();
   EXPECT_EQ(&destructible, &list.First());
 
-  testing::MockFunction<void()> separator;
+  ::testing::MockFunction<void()> separator;
   {
-    testing::InSequence s;
+    ::testing::InSequence s;
     EXPECT_CALL(destructible, Destruct());
     EXPECT_CALL(separator, Call());
     EXPECT_CALL(destructible, Destruct()).Times(0);
   }
 
   list.RemoveLast();
   separator.Call();
 }
 
 TEST(ContiguousContainerTest, DestructorCalledWithMultipleRemoveLastCalls) {
   // This container only requests space for one, but the implementation is
   // free to use more space if the allocator provides it.
   ContiguousContainer<MockDestructible> list(sizeof(MockDestructible),
                                              1 * sizeof(MockDestructible));
-  testing::MockFunction<void()> separator;
+  ::testing::MockFunction<void()> separator;
 
   // We should be okay to allocate and remove a single one, like before.
   list.AllocateAndConstruct<MockDestructible>();
   EXPECT_EQ(1u, list.size());
   {
-    testing::InSequence s;
+    ::testing::InSequence s;
     EXPECT_CALL(list[0], Destruct());
     EXPECT_CALL(separator, Call());
     EXPECT_CALL(list[0], Destruct()).Times(0);
   }
   list.RemoveLast();
   separator.Call();
   EXPECT_EQ(0u, list.size());
 
-  testing::Mock::VerifyAndClearExpectations(&separator);
+  ::testing::Mock::VerifyAndClearExpectations(&separator);
 
   // We should also be okay to allocate and remove multiple.
   list.AllocateAndConstruct<MockDestructible>();
   list.AllocateAndConstruct<MockDestructible>();
   list.AllocateAndConstruct<MockDestructible>();
   list.AllocateAndConstruct<MockDestructible>();
   list.AllocateAndConstruct<MockDestructible>();
   list.AllocateAndConstruct<MockDestructible>();
   EXPECT_EQ(6u, list.size());
   {
     // The last three should be destroyed by removeLast.
-    testing::InSequence s;
+    ::testing::InSequence s;
     EXPECT_CALL(list[5], Destruct());
     EXPECT_CALL(separator, Call());
     EXPECT_CALL(list[5], Destruct()).Times(0);
     EXPECT_CALL(list[4], Destruct());
     EXPECT_CALL(separator, Call());
     EXPECT_CALL(list[4], Destruct()).Times(0);
     EXPECT_CALL(list[3], Destruct());
     EXPECT_CALL(separator, Call());
     EXPECT_CALL(list[3], Destruct()).Times(0);
   }
@@ skipping 378 matching lines @@
   list.AppendByMoving(list[2], sizeof(Point3D));
   EXPECT_EQ(0u, reinterpret_cast<intptr_t>(&list.Last()) & (kMaxAlign - 1));
   list.AppendByMoving(list[3], sizeof(Point3D));
   EXPECT_EQ(0u, reinterpret_cast<intptr_t>(&list.Last()) & (kMaxAlign - 1));
   list.AppendByMoving(list[4], sizeof(Point2D));
   EXPECT_EQ(0u, reinterpret_cast<intptr_t>(&list.Last()) & (kMaxAlign - 1));
 }
 
 }  // namespace
 }  // namespace blink