Replace RefPtr<>::Get() with get()

This CL removes RefPtr<>::Get() in order to rename it to get().

Bug: 763844
Change-Id: I90f05a57d9f9bdf493983656a731585a7fb15ed8
Reviewed-on: https://chromium-review.googlesource.com/686515Reviewed-by: Kentaro Hara <haraken@chromium.org>
Reviewed-by: Yuta Kitamura <yutak@chromium.org>
Commit-Queue: Taiju Tsuiki <tzik@chromium.org>
Cr-Commit-Position: refs/heads/master@{#505302}

third_party/WebKit/Source/build/scripts/templates/fields/pointer.tmpl

@@ -6,7 +6,7 @@ static {{field.type_name}}* {{field.initial_method_name}}() {
   return {{field.default_value}};
 }
 {{field.type_name}}* {{field.getter_method_name}}() const {
-  return {{decode(field, getter_expression(field))}}.Get();
+  return {{decode(field, getter_expression(field))}}.get();
 }
 
 void {{field.setter_method_name}}({{field.wrapper_pointer_name}}<{{field.type_name}}> v) {

third_party/WebKit/Source/core/animation/ElementAnimations.cpp

@@ -98,7 +98,7 @@ DEFINE_TRACE(ElementAnimations) {
 const ComputedStyle* ElementAnimations::BaseComputedStyle() const {
 #if !DCHECK_IS_ON()
   if (IsAnimationStyleChange())
-    return base_computed_style_.Get();
+    return base_computed_style_.get();
 #endif
   return nullptr;
 }

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

@@ -18,7 +18,7 @@ class HighContrastImageClassifierTest : public ::testing::Test {
     String file_path = testing::BlinkRootDir();
     file_path.append(file_name);
     RefPtr<SharedBuffer> image_data = testing::ReadFromFile(file_path);
-    EXPECT_TRUE(image_data.Get());
+    EXPECT_TRUE(image_data.get());
 
     RefPtr<BitmapImage> image = BitmapImage::Create();
     image->SetData(image_data, true);
@@ -34,10 +34,10 @@ class HighContrastImageClassifierTest : public ::testing::Test {
 TEST_F(HighContrastImageClassifierTest, ShouldApplyHighContrastFilterToImage) {
   RefPtr<BitmapImage> image = LoadImage(
       "/LayoutTests/images/resources/blue-wheel-srgb-color-profile.png");
-  EXPECT_FALSE(classifier_.ShouldApplyHighContrastFilterToImage(*image.Get()));
+  EXPECT_FALSE(classifier_.ShouldApplyHighContrastFilterToImage(*image.get()));
 
   image = LoadImage("/LayoutTests/images/resources/grid.png");
-  EXPECT_TRUE(classifier_.ShouldApplyHighContrastFilterToImage(*image.Get()));
+  EXPECT_TRUE(classifier_.ShouldApplyHighContrastFilterToImage(*image.get()));
 }
 
 }  // namespace blink

third_party/WebKit/Source/platform/wtf/Functional.h

@@ -278,7 +278,7 @@ namespace base {
 
 template <typename T>
 struct BindUnwrapTraits<WTF::RefPtr<T>> {
-  static T* Unwrap(const WTF::RefPtr<T>& wrapped) { return wrapped.Get(); }
+  static T* Unwrap(const WTF::RefPtr<T>& wrapped) { return wrapped.get(); }
 };
 
 template <typename T>

third_party/WebKit/Source/platform/wtf/FunctionalTest.cpp

@@ -369,7 +369,7 @@ TEST(FunctionalTest, UnretainedWithRefCounted) {
   RefPtr<Number> five = Number::Create(5);
   EXPECT_EQ(1, five->RefCount());
   Function<int()> multiply_five_by_two_function =
-      WTF::Bind(MultiplyNumberByTwo, WTF::Unretained(five.Get()));
+      WTF::Bind(MultiplyNumberByTwo, WTF::Unretained(five.get()));
   EXPECT_EQ(1, five->RefCount());
   EXPECT_EQ(10, multiply_five_by_two_function());
   EXPECT_EQ(1, five->RefCount());

third_party/WebKit/Source/platform/wtf/HashFunctions.h

@@ -149,7 +149,7 @@ struct PtrHash {
 template <typename T>
 struct RefPtrHash : PtrHash<T> {
   using PtrHash<T>::GetHash;
-  static unsigned GetHash(const RefPtr<T>& key) { return GetHash(key.Get()); }
+  static unsigned GetHash(const RefPtr<T>& key) { return GetHash(key.get()); }
   using PtrHash<T>::Equal;
   static bool Equal(const RefPtr<T>& a, const RefPtr<T>& b) { return a == b; }
   static bool Equal(T* a, const RefPtr<T>& b) { return a == b; }

third_party/WebKit/Source/platform/wtf/HashMapTest.cpp

@@ -175,7 +175,7 @@ TEST(HashMapTest, RefPtrAsKey) {
   EXPECT_EQ(1, DummyRefCounted::ref_invokes_count_);
   EXPECT_EQ(1, map.at(ptr));
 
-  DummyRefCounted* raw_ptr = ptr.Get();
+  DummyRefCounted* raw_ptr = ptr.get();
 
   EXPECT_TRUE(map.Contains(raw_ptr));
   EXPECT_NE(map.end(), map.find(raw_ptr));

third_party/WebKit/Source/platform/wtf/HashSetTest.cpp

@@ -187,7 +187,7 @@ TEST(HashSetTest, HashSetRefPtr) {
   // Referenced only once (to store a copy in the container).
   EXPECT_EQ(1, DummyRefCounted::ref_invokes_count_);
 
-  DummyRefCounted* raw_ptr = ptr.Get();
+  DummyRefCounted* raw_ptr = ptr.get();
 
   EXPECT_TRUE(set.Contains(raw_ptr));
   EXPECT_NE(set.end(), set.find(raw_ptr));

third_party/WebKit/Source/platform/wtf/HashTraits.h

@@ -252,7 +252,7 @@ struct HashTraits<RefPtr<P>> : SimpleClassHashTraits<RefPtr<P>> {
   }
 
   typedef P* PeekOutType;
-  static PeekOutType Peek(const RefPtr<P>& value) { return value.Get(); }
+  static PeekOutType Peek(const RefPtr<P>& value) { return value.get(); }
 };
 
 template <typename T>

third_party/WebKit/Source/platform/wtf/ListHashSetTest.cpp

@@ -412,7 +412,7 @@ TYPED_TEST(ListOrLinkedHashSetRefPtrTest, WithRefPtr) {
   EXPECT_EQ(ptr, set.front());
   EXPECT_EQ(1, DummyRefCounted::ref_invokes_count_);
 
-  DummyRefCounted* raw_ptr = ptr.Get();
+  DummyRefCounted* raw_ptr = ptr.get();
 
   EXPECT_TRUE(set.Contains(ptr));
   EXPECT_TRUE(set.Contains(raw_ptr));

third_party/WebKit/Source/platform/wtf/RefPtr.h

@@ -73,7 +73,7 @@ class RefPtr {
   ALWAYS_INLINE RefPtr(const RefPtr& o) : ptr_(o.ptr_) { RefIfNotNull(ptr_); }
   template <typename U>
   RefPtr(const RefPtr<U>& o, EnsurePtrConvertibleArgDecl(U, T))
-      : ptr_(o.Get()) {
+      : ptr_(o.get()) {
     RefIfNotNull(ptr_);
   }
   RefPtr(RefPtr&& o) : ptr_(o.ptr_) { o.ptr_ = nullptr; }
@@ -83,10 +83,6 @@ class RefPtr {
 
   ALWAYS_INLINE ~RefPtr() { DerefIfNotNull(ptr_); }
 
-  // TODO(tzik): Get() is being renamed to get(). Once the rename finished,
-  // remove Get().
-  ALWAYS_INLINE T* Get() const { return get(); }
-
   ALWAYS_INLINE T* get() const { return ptr_; }
   T* LeakRef() WARN_UNUSED_RESULT;
 
@@ -148,57 +144,57 @@ inline void swap(RefPtr<T>& a, RefPtr<T>& b) {
 
 template <typename T, typename U>
 inline bool operator==(const RefPtr<T>& a, const RefPtr<U>& b) {
-  return a.Get() == b.Get();
+  return a.get() == b.get();
 }
 
 template <typename T, typename U>
 inline bool operator==(const RefPtr<T>& a, U* b) {
-  return a.Get() == b;
+  return a.get() == b;
 }
 
 template <typename T, typename U>
 inline bool operator==(T* a, const RefPtr<U>& b) {
-  return a == b.Get();
+  return a == b.get();
 }
 
 template <typename T>
 inline bool operator==(const RefPtr<T>& a, std::nullptr_t) {
-  return !a.Get();
+  return !a.get();
 }
 
 template <typename T>
 inline bool operator==(std::nullptr_t, const RefPtr<T>& b) {
-  return !b.Get();
+  return !b.get();
 }
 
 template <typename T, typename U>
 inline bool operator!=(const RefPtr<T>& a, const RefPtr<U>& b) {
-  return a.Get() != b.Get();
+  return a.get() != b.get();
 }
 
 template <typename T, typename U>
 inline bool operator!=(const RefPtr<T>& a, U* b) {
-  return a.Get() != b;
+  return a.get() != b;
 }
 
 template <typename T, typename U>
 inline bool operator!=(T* a, const RefPtr<U>& b) {
-  return a != b.Get();
+  return a != b.get();
 }
 
 template <typename T>
 inline bool operator!=(const RefPtr<T>& a, std::nullptr_t) {
-  return a.Get();
+  return a.get();
 }
 
 template <typename T>
 inline bool operator!=(std::nullptr_t, const RefPtr<T>& b) {
-  return b.Get();
+  return b.get();
 }
 
 template <typename T>
 inline T* GetPtr(const RefPtr<T>& p) {
-  return p.Get();
+  return p.get();
 }
 
 template <typename T>
@@ -209,7 +205,7 @@ class RefPtrValuePeeker {
   ALWAYS_INLINE RefPtrValuePeeker(T* p) : ptr_(p) {}
   ALWAYS_INLINE RefPtrValuePeeker(std::nullptr_t) : ptr_(nullptr) {}
   template <typename U>
-  RefPtrValuePeeker(const RefPtr<U>& p) : ptr_(p.Get()) {}
+  RefPtrValuePeeker(const RefPtr<U>& p) : ptr_(p.get()) {}
 
   ALWAYS_INLINE operator T*() const { return ptr_; }
 

third_party/WebKit/Source/platform/wtf/RefPtrTest.cpp

@@ -25,7 +25,7 @@ TEST(RefPtrTest, LeakRef) {
   RefPtr<StringImpl> string = StringImpl::Create("test");
   EXPECT_TRUE(string);
   EXPECT_TRUE(string->HasOneRef());
-  StringImpl* raw = string.Get();
+  StringImpl* raw = string.get();
   StringImpl* leaked = string.LeakRef();
   EXPECT_TRUE(!string);
   EXPECT_TRUE(leaked);

third_party/WebKit/Source/platform/wtf/TreeNodeTest.cpp

@@ -41,17 +41,17 @@ TEST(TreeNodeTest, AppendChild) {
   RefPtr<TestTree> first_child = TestTree::Create();
   RefPtr<TestTree> last_child = TestTree::Create();
 
-  root->AppendChild(first_child.Get());
-  EXPECT_EQ(root->FirstChild(), first_child.Get());
-  EXPECT_EQ(root->LastChild(), first_child.Get());
-  EXPECT_EQ(first_child->Parent(), root.Get());
-
-  root->AppendChild(last_child.Get());
-  EXPECT_EQ(root->FirstChild(), first_child.Get());
-  EXPECT_EQ(root->LastChild(), last_child.Get());
-  EXPECT_EQ(last_child->Previous(), first_child.Get());
-  EXPECT_EQ(first_child->Next(), last_child.Get());
-  EXPECT_EQ(last_child->Parent(), root.Get());
+  root->AppendChild(first_child.get());
+  EXPECT_EQ(root->FirstChild(), first_child.get());
+  EXPECT_EQ(root->LastChild(), first_child.get());
+  EXPECT_EQ(first_child->Parent(), root.get());
+
+  root->AppendChild(last_child.get());
+  EXPECT_EQ(root->FirstChild(), first_child.get());
+  EXPECT_EQ(root->LastChild(), last_child.get());
+  EXPECT_EQ(last_child->Previous(), first_child.get());
+  EXPECT_EQ(first_child->Next(), last_child.get());
+  EXPECT_EQ(last_child->Parent(), root.get());
 }
 
 TEST(TreeNodeTest, InsertBefore) {
@@ -61,28 +61,28 @@ TEST(TreeNodeTest, InsertBefore) {
   RefPtr<TestTree> last_child = TestTree::Create();
 
   // Inserting single node
-  root->InsertBefore(last_child.Get(), 0);
-  EXPECT_EQ(last_child->Parent(), root.Get());
-  EXPECT_EQ(root->FirstChild(), last_child.Get());
-  EXPECT_EQ(root->LastChild(), last_child.Get());
+  root->InsertBefore(last_child.get(), 0);
+  EXPECT_EQ(last_child->Parent(), root.get());
+  EXPECT_EQ(root->FirstChild(), last_child.get());
+  EXPECT_EQ(root->LastChild(), last_child.get());
 
   // Then prepend
-  root->InsertBefore(first_child.Get(), last_child.Get());
-  EXPECT_EQ(first_child->Parent(), root.Get());
-  EXPECT_EQ(root->FirstChild(), first_child.Get());
-  EXPECT_EQ(root->LastChild(), last_child.Get());
-  EXPECT_EQ(first_child->Next(), last_child.Get());
-  EXPECT_EQ(first_child.Get(), last_child->Previous());
+  root->InsertBefore(first_child.get(), last_child.get());
+  EXPECT_EQ(first_child->Parent(), root.get());
+  EXPECT_EQ(root->FirstChild(), first_child.get());
+  EXPECT_EQ(root->LastChild(), last_child.get());
+  EXPECT_EQ(first_child->Next(), last_child.get());
+  EXPECT_EQ(first_child.get(), last_child->Previous());
 
   // Inserting in the middle
-  root->InsertBefore(middle_child.Get(), last_child.Get());
-  EXPECT_EQ(middle_child->Parent(), root.Get());
-  EXPECT_EQ(root->FirstChild(), first_child.Get());
-  EXPECT_EQ(root->LastChild(), last_child.Get());
-  EXPECT_EQ(middle_child->Previous(), first_child.Get());
-  EXPECT_EQ(middle_child->Next(), last_child.Get());
-  EXPECT_EQ(first_child->Next(), middle_child.Get());
-  EXPECT_EQ(last_child->Previous(), middle_child.Get());
+  root->InsertBefore(middle_child.get(), last_child.get());
+  EXPECT_EQ(middle_child->Parent(), root.get());
+  EXPECT_EQ(root->FirstChild(), first_child.get());
+  EXPECT_EQ(root->LastChild(), last_child.get());
+  EXPECT_EQ(middle_child->Previous(), first_child.get());
+  EXPECT_EQ(middle_child->Next(), last_child.get());
+  EXPECT_EQ(first_child->Next(), middle_child.get());
+  EXPECT_EQ(last_child->Previous(), middle_child.get());
 }
 
 TEST(TreeNodeTest, RemoveSingle) {
@@ -90,13 +90,13 @@ TEST(TreeNodeTest, RemoveSingle) {
   RefPtr<TestTree> child = TestTree::Create();
   RefPtr<TestTree> null_node;
 
-  root->AppendChild(child.Get());
-  root->RemoveChild(child.Get());
-  EXPECT_EQ(child->Next(), null_node.Get());
-  EXPECT_EQ(child->Previous(), null_node.Get());
-  EXPECT_EQ(child->Parent(), null_node.Get());
-  EXPECT_EQ(root->FirstChild(), null_node.Get());
-  EXPECT_EQ(root->LastChild(), null_node.Get());
+  root->AppendChild(child.get());
+  root->RemoveChild(child.get());
+  EXPECT_EQ(child->Next(), null_node.get());
+  EXPECT_EQ(child->Previous(), null_node.get());
+  EXPECT_EQ(child->Parent(), null_node.get());
+  EXPECT_EQ(root->FirstChild(), null_node.get());
+  EXPECT_EQ(root->LastChild(), null_node.get());
 }
 
 class Trio {
@@ -108,9 +108,9 @@ class Trio {
         last_child(TestTree::Create()) {}
 
   void AppendChildren() {
-    root->AppendChild(first_child.Get());
-    root->AppendChild(middle_child.Get());
-    root->AppendChild(last_child.Get());
+    root->AppendChild(first_child.get());
+    root->AppendChild(middle_child.get());
+    root->AppendChild(last_child.get());
   }
 
   RefPtr<TestTree> root;
@@ -123,12 +123,12 @@ TEST(TreeNodeTest, RemoveMiddle) {
   Trio trio;
   trio.AppendChildren();
 
-  trio.root->RemoveChild(trio.middle_child.Get());
+  trio.root->RemoveChild(trio.middle_child.get());
   EXPECT_TRUE(trio.middle_child->Orphan());
-  EXPECT_EQ(trio.first_child->Next(), trio.last_child.Get());
-  EXPECT_EQ(trio.last_child->Previous(), trio.first_child.Get());
-  EXPECT_EQ(trio.root->FirstChild(), trio.first_child.Get());
-  EXPECT_EQ(trio.root->LastChild(), trio.last_child.Get());
+  EXPECT_EQ(trio.first_child->Next(), trio.last_child.get());
+  EXPECT_EQ(trio.last_child->Previous(), trio.first_child.get());
+  EXPECT_EQ(trio.root->FirstChild(), trio.first_child.get());
+  EXPECT_EQ(trio.root->LastChild(), trio.last_child.get());
 }
 
 TEST(TreeNodeTest, RemoveLast) {
@@ -136,11 +136,11 @@ TEST(TreeNodeTest, RemoveLast) {
   Trio trio;
   trio.AppendChildren();
 
-  trio.root->RemoveChild(trio.last_child.Get());
+  trio.root->RemoveChild(trio.last_child.get());
   EXPECT_TRUE(trio.last_child->Orphan());
-  EXPECT_EQ(trio.middle_child->Next(), null_node.Get());
-  EXPECT_EQ(trio.root->FirstChild(), trio.first_child.Get());
-  EXPECT_EQ(trio.root->LastChild(), trio.middle_child.Get());
+  EXPECT_EQ(trio.middle_child->Next(), null_node.get());
+  EXPECT_EQ(trio.root->FirstChild(), trio.first_child.get());
+  EXPECT_EQ(trio.root->LastChild(), trio.middle_child.get());
 }
 
 TEST(TreeNodeTest, RemoveFirst) {
@@ -148,11 +148,11 @@ TEST(TreeNodeTest, RemoveFirst) {
   Trio trio;
   trio.AppendChildren();
 
-  trio.root->RemoveChild(trio.first_child.Get());
+  trio.root->RemoveChild(trio.first_child.get());
   EXPECT_TRUE(trio.first_child->Orphan());
-  EXPECT_EQ(trio.middle_child->Previous(), null_node.Get());
-  EXPECT_EQ(trio.root->FirstChild(), trio.middle_child.Get());
-  EXPECT_EQ(trio.root->LastChild(), trio.last_child.Get());
+  EXPECT_EQ(trio.middle_child->Previous(), null_node.get());
+  EXPECT_EQ(trio.root->FirstChild(), trio.middle_child.get());
+  EXPECT_EQ(trio.root->LastChild(), trio.last_child.get());
 }
 
 TEST(TreeNodeTest, TakeChildrenFrom) {
@@ -160,13 +160,13 @@ TEST(TreeNodeTest, TakeChildrenFrom) {
   Trio trio;
   trio.AppendChildren();
 
-  new_parent->TakeChildrenFrom(trio.root.Get());
+  new_parent->TakeChildrenFrom(trio.root.get());
 
   EXPECT_FALSE(trio.root->HasChildren());
   EXPECT_TRUE(new_parent->HasChildren());
-  EXPECT_EQ(trio.first_child.Get(), new_parent->FirstChild());
-  EXPECT_EQ(trio.middle_child.Get(), new_parent->FirstChild()->Next());
-  EXPECT_EQ(trio.last_child.Get(), new_parent->LastChild());
+  EXPECT_EQ(trio.first_child.get(), new_parent->FirstChild());
+  EXPECT_EQ(trio.middle_child.get(), new_parent->FirstChild()->Next());
+  EXPECT_EQ(trio.last_child.get(), new_parent->LastChild());
 }
 
 class TrioWithGrandChild : public Trio {
@@ -175,7 +175,7 @@ class TrioWithGrandChild : public Trio {
 
   void AppendChildren() {
     Trio::AppendChildren();
-    middle_child->AppendChild(grand_child.Get());
+    middle_child->AppendChild(grand_child.get());
   }
 
   RefPtr<TestTree> grand_child;
@@ -185,12 +185,12 @@ TEST(TreeNodeTest, TraverseNext) {
   TrioWithGrandChild trio;
   trio.AppendChildren();
 
-  TestTree* order[] = {trio.root.Get(), trio.first_child.Get(),
-                       trio.middle_child.Get(), trio.grand_child.Get(),
-                       trio.last_child.Get()};
+  TestTree* order[] = {trio.root.get(), trio.first_child.get(),
+                       trio.middle_child.get(), trio.grand_child.get(),
+                       trio.last_child.get()};
 
   unsigned order_index = 0;
-  for (TestTree *node = trio.root.Get(); node;
+  for (TestTree *node = trio.root.get(); node;
        node = TraverseNext(node), order_index++)
     EXPECT_EQ(node, order[order_index]);
   EXPECT_EQ(order_index, sizeof(order) / sizeof(TestTree*));
@@ -200,12 +200,12 @@ TEST(TreeNodeTest, TraverseNextPostORder) {
   TrioWithGrandChild trio;
   trio.AppendChildren();
 
-  TestTree* order[] = {trio.first_child.Get(), trio.grand_child.Get(),
-                       trio.middle_child.Get(), trio.last_child.Get(),
-                       trio.root.Get()};
+  TestTree* order[] = {trio.first_child.get(), trio.grand_child.get(),
+                       trio.middle_child.get(), trio.last_child.get(),
+                       trio.root.get()};
 
   unsigned order_index = 0;
-  for (TestTree *node = TraverseFirstPostOrder(trio.root.Get()); node;
+  for (TestTree *node = TraverseFirstPostOrder(trio.root.get()); node;
        node = TraverseNextPostOrder(node), order_index++)
     EXPECT_EQ(node, order[order_index]);
   EXPECT_EQ(order_index, sizeof(order) / sizeof(TestTree*));

third_party/WebKit/Source/platform/wtf/text/CString.h

@@ -91,7 +91,7 @@ class WTF_EXPORT CString {
 
   bool IsSafeToSendToAnotherThread() const;
 
-  CStringImpl* Impl() const { return buffer_.Get(); }
+  CStringImpl* Impl() const { return buffer_.get(); }
 
  private:
   RefPtr<CStringImpl> buffer_;

third_party/WebKit/Source/platform/wtf/text/StringHash.h

@@ -62,7 +62,7 @@ struct StringHash {
     return key->GetHash();
   }
   static bool Equal(const RefPtr<StringImpl>& a, const RefPtr<StringImpl>& b) {
-    return Equal(a.Get(), b.Get());
+    return Equal(a.get(), b.get());
   }
 
   static unsigned GetHash(const String& key) { return key.Impl()->GetHash(); }
@@ -113,11 +113,11 @@ class CaseFoldingHash {
   }
 
   static unsigned GetHash(const RefPtr<StringImpl>& key) {
-    return GetHash(key.Get());
+    return GetHash(key.get());
   }
 
   static bool Equal(const RefPtr<StringImpl>& a, const RefPtr<StringImpl>& b) {
-    return Equal(a.Get(), b.Get());
+    return Equal(a.get(), b.get());
   }
 
   static unsigned GetHash(const String& key) { return GetHash(key.Impl()); }

third_party/WebKit/Source/platform/wtf/text/StringImplTest.cpp

@@ -48,27 +48,27 @@ TEST(StringImplTest, LowerASCII) {
   EXPECT_TRUE(test_string_impl->Is8Bit());
   EXPECT_TRUE(StringImpl::Create("a\xE1")->Is8Bit());
 
-  EXPECT_TRUE(Equal(test_string_impl.Get(),
-                    StringImpl::Create("link")->LowerASCII().Get()));
-  EXPECT_TRUE(Equal(test_string_impl.Get(),
-                    StringImpl::Create("LINK")->LowerASCII().Get()));
-  EXPECT_TRUE(Equal(test_string_impl.Get(),
-                    StringImpl::Create("lInk")->LowerASCII().Get()));
-
-  EXPECT_TRUE(Equal(StringImpl::Create("LINK")->LowerUnicode().Get(),
-                    StringImpl::Create("LINK")->LowerASCII().Get()));
-  EXPECT_TRUE(Equal(StringImpl::Create("lInk")->LowerUnicode().Get(),
-                    StringImpl::Create("lInk")->LowerASCII().Get()));
-
-  EXPECT_TRUE(Equal(StringImpl::Create("a\xE1").Get(),
-                    StringImpl::Create("A\xE1")->LowerASCII().Get()));
-  EXPECT_TRUE(Equal(StringImpl::Create("a\xC1").Get(),
-                    StringImpl::Create("A\xC1")->LowerASCII().Get()));
-
-  EXPECT_FALSE(Equal(StringImpl::Create("a\xE1").Get(),
-                     StringImpl::Create("a\xC1")->LowerASCII().Get()));
-  EXPECT_FALSE(Equal(StringImpl::Create("A\xE1").Get(),
-                     StringImpl::Create("A\xC1")->LowerASCII().Get()));
+  EXPECT_TRUE(Equal(test_string_impl.get(),
+                    StringImpl::Create("link")->LowerASCII().get()));
+  EXPECT_TRUE(Equal(test_string_impl.get(),
+                    StringImpl::Create("LINK")->LowerASCII().get()));
+  EXPECT_TRUE(Equal(test_string_impl.get(),
+                    StringImpl::Create("lInk")->LowerASCII().get()));
+
+  EXPECT_TRUE(Equal(StringImpl::Create("LINK")->LowerUnicode().get(),
+                    StringImpl::Create("LINK")->LowerASCII().get()));
+  EXPECT_TRUE(Equal(StringImpl::Create("lInk")->LowerUnicode().get(),
+                    StringImpl::Create("lInk")->LowerASCII().get()));
+
+  EXPECT_TRUE(Equal(StringImpl::Create("a\xE1").get(),
+                    StringImpl::Create("A\xE1")->LowerASCII().get()));
+  EXPECT_TRUE(Equal(StringImpl::Create("a\xC1").get(),
+                    StringImpl::Create("A\xC1")->LowerASCII().get()));
+
+  EXPECT_FALSE(Equal(StringImpl::Create("a\xE1").get(),
+                     StringImpl::Create("a\xC1")->LowerASCII().get()));
+  EXPECT_FALSE(Equal(StringImpl::Create("A\xE1").get(),
+                     StringImpl::Create("A\xC1")->LowerASCII().get()));
 
   static const UChar kTest[5] = {0x006c, 0x0069, 0x006e, 0x006b, 0};  // link
   static const UChar kTestCapitalized[5] = {0x004c, 0x0049, 0x004e, 0x004b,
@@ -77,11 +77,11 @@ TEST(StringImplTest, LowerASCII) {
   RefPtr<StringImpl> test_string_impl16 = StringImpl::Create(kTest, 4);
   EXPECT_FALSE(test_string_impl16->Is8Bit());
 
-  EXPECT_TRUE(Equal(test_string_impl16.Get(),
-                    StringImpl::Create(kTest, 4)->LowerASCII().Get()));
+  EXPECT_TRUE(Equal(test_string_impl16.get(),
+                    StringImpl::Create(kTest, 4)->LowerASCII().get()));
   EXPECT_TRUE(
-      Equal(test_string_impl16.Get(),
-            StringImpl::Create(kTestCapitalized, 4)->LowerASCII().Get()));
+      Equal(test_string_impl16.get(),
+            StringImpl::Create(kTestCapitalized, 4)->LowerASCII().get()));
 
   static const UChar kTestWithNonASCII[3] = {0x0061, 0x00e1, 0};  // a\xE1
   static const UChar kTestWithNonASCIIComparison[3] = {0x0061, 0x00c1,
@@ -93,11 +93,11 @@ TEST(StringImplTest, LowerASCII) {
   RefPtr<const StringImpl> const_ref = test_string_impl->IsolatedCopy();
   DCHECK(const_ref->HasOneRef());
   EXPECT_TRUE(Equal(
-      StringImpl::Create(kTestWithNonASCII, 2).Get(),
-      StringImpl::Create(kTestWithNonASCIICapitalized, 2)->LowerASCII().Get()));
+      StringImpl::Create(kTestWithNonASCII, 2).get(),
+      StringImpl::Create(kTestWithNonASCIICapitalized, 2)->LowerASCII().get()));
   EXPECT_FALSE(Equal(
-      StringImpl::Create(kTestWithNonASCII, 2).Get(),
-      StringImpl::Create(kTestWithNonASCIIComparison, 2)->LowerASCII().Get()));
+      StringImpl::Create(kTestWithNonASCII, 2).get(),
+      StringImpl::Create(kTestWithNonASCIIComparison, 2)->LowerASCII().get()));
 }
 
 TEST(StringImplTest, UpperASCII) {
@@ -105,27 +105,27 @@ TEST(StringImplTest, UpperASCII) {
   EXPECT_TRUE(test_string_impl->Is8Bit());
   EXPECT_TRUE(StringImpl::Create("a\xE1")->Is8Bit());
 
-  EXPECT_TRUE(Equal(test_string_impl.Get(),
-                    StringImpl::Create("link")->UpperASCII().Get()));
-  EXPECT_TRUE(Equal(test_string_impl.Get(),
-                    StringImpl::Create("LINK")->UpperASCII().Get()));
-  EXPECT_TRUE(Equal(test_string_impl.Get(),
-                    StringImpl::Create("lInk")->UpperASCII().Get()));
+  EXPECT_TRUE(Equal(test_string_impl.get(),
+                    StringImpl::Create("link")->UpperASCII().get()));
+  EXPECT_TRUE(Equal(test_string_impl.get(),
+                    StringImpl::Create("LINK")->UpperASCII().get()));
+  EXPECT_TRUE(Equal(test_string_impl.get(),
+                    StringImpl::Create("lInk")->UpperASCII().get()));
 
-  EXPECT_TRUE(Equal(StringImpl::Create("LINK")->UpperUnicode().Get(),
-                    StringImpl::Create("LINK")->UpperASCII().Get()));
-  EXPECT_TRUE(Equal(StringImpl::Create("lInk")->UpperUnicode().Get(),
-                    StringImpl::Create("lInk")->UpperASCII().Get()));
+  EXPECT_TRUE(Equal(StringImpl::Create("LINK")->UpperUnicode().get(),
+                    StringImpl::Create("LINK")->UpperASCII().get()));
+  EXPECT_TRUE(Equal(StringImpl::Create("lInk")->UpperUnicode().get(),
+                    StringImpl::Create("lInk")->UpperASCII().get()));
 
-  EXPECT_TRUE(Equal(StringImpl::Create("A\xE1").Get(),
-                    StringImpl::Create("a\xE1")->UpperASCII().Get()));
-  EXPECT_TRUE(Equal(StringImpl::Create("A\xC1").Get(),
-                    StringImpl::Create("a\xC1")->UpperASCII().Get()));
+  EXPECT_TRUE(Equal(StringImpl::Create("A\xE1").get(),
+                    StringImpl::Create("a\xE1")->UpperASCII().get()));
+  EXPECT_TRUE(Equal(StringImpl::Create("A\xC1").get(),
+                    StringImpl::Create("a\xC1")->UpperASCII().get()));
 
-  EXPECT_FALSE(Equal(StringImpl::Create("A\xE1").Get(),
-                     StringImpl::Create("a\xC1")->UpperASCII().Get()));
-  EXPECT_FALSE(Equal(StringImpl::Create("A\xE1").Get(),
-                     StringImpl::Create("A\xC1")->UpperASCII().Get()));
+  EXPECT_FALSE(Equal(StringImpl::Create("A\xE1").get(),
+                     StringImpl::Create("a\xC1")->UpperASCII().get()));
+  EXPECT_FALSE(Equal(StringImpl::Create("A\xE1").get(),
+                     StringImpl::Create("A\xC1")->UpperASCII().get()));
 
   static const UChar kTest[5] = {0x006c, 0x0069, 0x006e, 0x006b, 0};  // link
   static const UChar kTestCapitalized[5] = {0x004c, 0x0049, 0x004e, 0x004b,
@@ -135,11 +135,11 @@ TEST(StringImplTest, UpperASCII) {
       StringImpl::Create(kTestCapitalized, 4);
   EXPECT_FALSE(test_string_impl16->Is8Bit());
 
-  EXPECT_TRUE(Equal(test_string_impl16.Get(),
-                    StringImpl::Create(kTest, 4)->UpperASCII().Get()));
+  EXPECT_TRUE(Equal(test_string_impl16.get(),
+                    StringImpl::Create(kTest, 4)->UpperASCII().get()));
   EXPECT_TRUE(
-      Equal(test_string_impl16.Get(),
-            StringImpl::Create(kTestCapitalized, 4)->UpperASCII().Get()));
+      Equal(test_string_impl16.get(),
+            StringImpl::Create(kTestCapitalized, 4)->UpperASCII().get()));
 
   static const UChar kTestWithNonASCII[3] = {0x0061, 0x00e1, 0};  // a\xE1
   static const UChar kTestWithNonASCIIComparison[3] = {0x0061, 0x00c1,
@@ -151,11 +151,11 @@ TEST(StringImplTest, UpperASCII) {
   RefPtr<const StringImpl> const_ref = test_string_impl->IsolatedCopy();
   DCHECK(const_ref->HasOneRef());
   EXPECT_TRUE(
-      Equal(StringImpl::Create(kTestWithNonASCIICapitalized, 2).Get(),
-            StringImpl::Create(kTestWithNonASCII, 2)->UpperASCII().Get()));
+      Equal(StringImpl::Create(kTestWithNonASCIICapitalized, 2).get(),
+            StringImpl::Create(kTestWithNonASCII, 2)->UpperASCII().get()));
   EXPECT_FALSE(Equal(
-      StringImpl::Create(kTestWithNonASCIICapitalized, 2).Get(),
-      StringImpl::Create(kTestWithNonASCIIComparison, 2)->UpperASCII().Get()));
+      StringImpl::Create(kTestWithNonASCIICapitalized, 2).get(),
+      StringImpl::Create(kTestWithNonASCIIComparison, 2)->UpperASCII().get()));
 }
 
 }  // namespace WTF

third_party/WebKit/Source/platform/wtf/text/StringViewTest.cpp

@@ -19,61 +19,61 @@ TEST(StringViewTest, ConstructionStringImpl8) {
   RefPtr<StringImpl> impl8_bit = StringImpl::Create(kChars8, 5);
 
   // StringView(StringImpl*);
-  ASSERT_TRUE(StringView(impl8_bit.Get()).Is8Bit());
-  EXPECT_FALSE(StringView(impl8_bit.Get()).IsNull());
+  ASSERT_TRUE(StringView(impl8_bit.get()).Is8Bit());
+  EXPECT_FALSE(StringView(impl8_bit.get()).IsNull());
   EXPECT_EQ(impl8_bit->Characters8(),
-            StringView(impl8_bit.Get()).Characters8());
-  EXPECT_EQ(impl8_bit->length(), StringView(impl8_bit.Get()).length());
-  EXPECT_STREQ(kChars, StringView(impl8_bit.Get()).ToString().Utf8().data());
+            StringView(impl8_bit.get()).Characters8());
+  EXPECT_EQ(impl8_bit->length(), StringView(impl8_bit.get()).length());
+  EXPECT_STREQ(kChars, StringView(impl8_bit.get()).ToString().Utf8().data());
 
   // StringView(StringImpl*, unsigned offset);
-  ASSERT_TRUE(StringView(impl8_bit.Get(), 2).Is8Bit());
-  EXPECT_FALSE(StringView(impl8_bit.Get(), 2).IsNull());
+  ASSERT_TRUE(StringView(impl8_bit.get(), 2).Is8Bit());
+  EXPECT_FALSE(StringView(impl8_bit.get(), 2).IsNull());
   EXPECT_EQ(impl8_bit->Characters8() + 2,
-            StringView(impl8_bit.Get(), 2).Characters8());
-  EXPECT_EQ(3u, StringView(impl8_bit.Get(), 2).length());
-  EXPECT_EQ(StringView("345"), StringView(impl8_bit.Get(), 2));
-  EXPECT_STREQ("345", StringView(impl8_bit.Get(), 2).ToString().Utf8().data());
+            StringView(impl8_bit.get(), 2).Characters8());
+  EXPECT_EQ(3u, StringView(impl8_bit.get(), 2).length());
+  EXPECT_EQ(StringView("345"), StringView(impl8_bit.get(), 2));
+  EXPECT_STREQ("345", StringView(impl8_bit.get(), 2).ToString().Utf8().data());
 
   // StringView(StringImpl*, unsigned offset, unsigned length);
-  ASSERT_TRUE(StringView(impl8_bit.Get(), 2, 1).Is8Bit());
-  EXPECT_FALSE(StringView(impl8_bit.Get(), 2, 1).IsNull());
+  ASSERT_TRUE(StringView(impl8_bit.get(), 2, 1).Is8Bit());
+  EXPECT_FALSE(StringView(impl8_bit.get(), 2, 1).IsNull());
   EXPECT_EQ(impl8_bit->Characters8() + 2,
-            StringView(impl8_bit.Get(), 2, 1).Characters8());
-  EXPECT_EQ(1u, StringView(impl8_bit.Get(), 2, 1).length());
-  EXPECT_EQ(StringView("3"), StringView(impl8_bit.Get(), 2, 1));
-  EXPECT_STREQ("3", StringView(impl8_bit.Get(), 2, 1).ToString().Utf8().data());
+            StringView(impl8_bit.get(), 2, 1).Characters8());
+  EXPECT_EQ(1u, StringView(impl8_bit.get(), 2, 1).length());
+  EXPECT_EQ(StringView("3"), StringView(impl8_bit.get(), 2, 1));
+  EXPECT_STREQ("3", StringView(impl8_bit.get(), 2, 1).ToString().Utf8().data());
 }
 
 TEST(StringViewTest, ConstructionStringImpl16) {
   RefPtr<StringImpl> impl16_bit = StringImpl::Create(kChars16, 5);
 
   // StringView(StringImpl*);
-  ASSERT_FALSE(StringView(impl16_bit.Get()).Is8Bit());
-  EXPECT_FALSE(StringView(impl16_bit.Get()).IsNull());
+  ASSERT_FALSE(StringView(impl16_bit.get()).Is8Bit());
+  EXPECT_FALSE(StringView(impl16_bit.get()).IsNull());
   EXPECT_EQ(impl16_bit->Characters16(),
-            StringView(impl16_bit.Get()).Characters16());
-  EXPECT_EQ(impl16_bit->length(), StringView(impl16_bit.Get()).length());
-  EXPECT_STREQ(kChars, StringView(impl16_bit.Get()).ToString().Utf8().data());
+            StringView(impl16_bit.get()).Characters16());
+  EXPECT_EQ(impl16_bit->length(), StringView(impl16_bit.get()).length());
+  EXPECT_STREQ(kChars, StringView(impl16_bit.get()).ToString().Utf8().data());
 
   // StringView(StringImpl*, unsigned offset);
-  ASSERT_FALSE(StringView(impl16_bit.Get(), 2).Is8Bit());
-  EXPECT_FALSE(StringView(impl16_bit.Get(), 2).IsNull());
+  ASSERT_FALSE(StringView(impl16_bit.get(), 2).Is8Bit());
+  EXPECT_FALSE(StringView(impl16_bit.get(), 2).IsNull());
   EXPECT_EQ(impl16_bit->Characters16() + 2,
-            StringView(impl16_bit.Get(), 2).Characters16());
-  EXPECT_EQ(3u, StringView(impl16_bit.Get(), 2).length());
-  EXPECT_EQ(StringView("345"), StringView(impl16_bit.Get(), 2));
-  EXPECT_STREQ("345", StringView(impl16_bit.Get(), 2).ToString().Utf8().data());
+            StringView(impl16_bit.get(), 2).Characters16());
+  EXPECT_EQ(3u, StringView(impl16_bit.get(), 2).length());
+  EXPECT_EQ(StringView("345"), StringView(impl16_bit.get(), 2));
+  EXPECT_STREQ("345", StringView(impl16_bit.get(), 2).ToString().Utf8().data());
 
   // StringView(StringImpl*, unsigned offset, unsigned length);
-  ASSERT_FALSE(StringView(impl16_bit.Get(), 2, 1).Is8Bit());
-  EXPECT_FALSE(StringView(impl16_bit.Get(), 2, 1).IsNull());
+  ASSERT_FALSE(StringView(impl16_bit.get(), 2, 1).Is8Bit());
+  EXPECT_FALSE(StringView(impl16_bit.get(), 2, 1).IsNull());
   EXPECT_EQ(impl16_bit->Characters16() + 2,
-            StringView(impl16_bit.Get(), 2, 1).Characters16());
-  EXPECT_EQ(1u, StringView(impl16_bit.Get(), 2, 1).length());
-  EXPECT_EQ(StringView("3"), StringView(impl16_bit.Get(), 2, 1));
+            StringView(impl16_bit.get(), 2, 1).Characters16());
+  EXPECT_EQ(1u, StringView(impl16_bit.get(), 2, 1).length());
+  EXPECT_EQ(StringView("3"), StringView(impl16_bit.get(), 2, 1));
   EXPECT_STREQ("3",
-               StringView(impl16_bit.Get(), 2, 1).ToString().Utf8().data());
+               StringView(impl16_bit.get(), 2, 1).ToString().Utf8().data());
 }
 
 TEST(StringViewTest, ConstructionStringImplRef8) {

third_party/WebKit/Source/platform/wtf/text/WTFString.h

@@ -112,7 +112,7 @@ class WTF_EXPORT String {
   bool IsNull() const { return !impl_; }
   bool IsEmpty() const { return !impl_ || !impl_->length(); }
 
-  StringImpl* Impl() const { return impl_.Get(); }
+  StringImpl* Impl() const { return impl_.get(); }
   RefPtr<StringImpl> ReleaseImpl() { return std::move(impl_); }
 
   unsigned length() const {

third_party/WebKit/Source/platform/wtf/typed_arrays/ArrayBuffer.cpp

@@ -92,7 +92,7 @@ void ArrayBuffer::AddView(ArrayBufferView* view) {
 }
 
 void ArrayBuffer::RemoveView(ArrayBufferView* view) {
-  DCHECK_EQ(this, view->buffer_.Get());
+  DCHECK_EQ(this, view->buffer_.get());
   if (view->next_view_)
     view->next_view_->prev_view_ = view->prev_view_;
   if (view->prev_view_)

third_party/WebKit/Source/platform/wtf/typed_arrays/ArrayBufferBuilder.h

@@ -56,7 +56,7 @@ class WTF_EXPORT ArrayBufferBuilder final {
     buffer_ = ArrayBuffer::Create(capacity, 1);
   }
 
-  bool IsValid() const { return buffer_.Get(); }
+  bool IsValid() const { return buffer_.get(); }
 
   // Appending empty data is not allowed.
   unsigned Append(const char* data, unsigned length);

third_party/WebKit/Source/platform/wtf/typed_arrays/ArrayBufferBuilderTest.cpp

@@ -145,7 +145,7 @@ TEST(ArrayBufferBuilderTest, ToArrayBufferSameAddressIfExactCapacity) {
 
   RefPtr<ArrayBuffer> result1 = builder.ToArrayBuffer();
   RefPtr<ArrayBuffer> result2 = builder.ToArrayBuffer();
-  EXPECT_EQ(result1.Get(), result2.Get());
+  EXPECT_EQ(result1.get(), result2.get());
 }
 
 TEST(ArrayBufferBuilderTest, ToString) {

third_party/WebKit/Source/platform/wtf/typed_arrays/ArrayBufferView.h

@@ -51,7 +51,7 @@ class WTF_EXPORT ArrayBufferView : public RefCounted<ArrayBufferView> {
   virtual ViewType GetType() const = 0;
   const char* TypeName();
 
-  ArrayBuffer* Buffer() const { return buffer_.Get(); }
+  ArrayBuffer* Buffer() const { return buffer_.get(); }
 
   void* BaseAddress() const {
     DCHECK(!IsShared());

third_party/WebKit/Source/platform/wtf/typed_arrays/TypedArrayBase.h

@@ -87,7 +87,7 @@ class TypedArrayBase : public ArrayBufferView {
   static RefPtr<Subclass> Create(RefPtr<ArrayBuffer> buffer,
                                  unsigned byte_offset,
                                  unsigned length) {
-    CHECK(VerifySubRange<T>(buffer.Get(), byte_offset, length));
+    CHECK(VerifySubRange<T>(buffer.get(), byte_offset, length));
     return WTF::AdoptRef(new Subclass(std::move(buffer), byte_offset, length));
   }