Make operators on scoped_ptr match the ones defined for std::unique_ptr

Currently scoped_ptr is missing comparison operators other than == and
!=, and it defines those operators incorrectly (it compares to a raw
pointer but unique_ptr compares to a unique_ptr).

This fixes the operator== and !=, and adds .get() at a bunch of
callsites. And adds the < > <= >= operators so that we don't have any
differences in where you can use it. This will help the transition
from scoped_ptr to unique_ptr as no code will have to change along with
the rename wrt these operators.

R=Nico, dcheng
TBR=ellyjones, sky, jochen, wez, rockot, droger
BUG=554390
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel

Review URL: https://codereview.chromium.org/1440593004

Cr-Commit-Position: refs/heads/master@{#359957}

47 files changed, 363 insertions, 173 deletions

diff --git a/ash/shelf/shelf_view.cc b/ash/shelf/shelf_view.cc
index 9f3fe0a..95c7e08 100644
--- a/ash/shelf/shelf_view.cc
+++ b/ash/shelf/shelf_view.cc
@@ -1900,7 +1900,7 @@ void ShelfView::OnBoundsAnimatorProgressed(views::BoundsAnimator* animator) {
 }
 
 void ShelfView::OnBoundsAnimatorDone(views::BoundsAnimator* animator) {
-  if (snap_back_from_rip_off_view_ && animator == bounds_animator_) {
+  if (snap_back_from_rip_off_view_ && animator == bounds_animator_.get()) {
     if (!animator->IsAnimating(snap_back_from_rip_off_view_)) {
       // Coming here the animation of the ShelfButton is finished and the
       // previously hidden status can be shown again. Since the button itself
diff --git a/ash/wm/overview/window_selector_unittest.cc b/ash/wm/overview/window_selector_unittest.cc
index 0e15230..01fdf63 100644
--- a/ash/wm/overview/window_selector_unittest.cc
+++ b/ash/wm/overview/window_selector_unittest.cc
@@ -739,8 +739,7 @@ TEST_F(WindowSelectorTest, WindowDoesNotReceiveEvents) {
 
   // The event should target the window because we are still not in overview
   // mode.
-  EXPECT_EQ(window, static_cast<aura::Window*>(
-      targeter->FindTargetForEvent(root_target, &event1)));
+  EXPECT_EQ(window.get(), targeter->FindTargetForEvent(root_target, &event1));
 
   ToggleOverview();
 
@@ -751,8 +750,7 @@ TEST_F(WindowSelectorTest, WindowDoesNotReceiveEvents) {
                         ui::EventTimeForNow(), ui::EF_NONE, ui::EF_NONE);
 
   // Now the transparent window should be intercepting this event.
-  EXPECT_NE(window, static_cast<aura::Window*>(
-        targeter->FindTargetForEvent(root_target, &event2)));
+  EXPECT_NE(window.get(), targeter->FindTargetForEvent(root_target, &event2));
 }
 
 // Tests that clicking on the close button effectively closes the window.
diff --git a/ash/wm/system_gesture_event_filter_unittest.cc b/ash/wm/system_gesture_event_filter_unittest.cc
index fc7934f..c5d8936 100644
--- a/ash/wm/system_gesture_event_filter_unittest.cc
+++ b/ash/wm/system_gesture_event_filter_unittest.cc
@@ -200,7 +200,7 @@ TEST_F(SystemGestureEventFilterTest, LongPressAffordanceStateOnCaptureLoss) {
 
   base::OneShotTimer* timer = GetLongPressAffordanceTimer();
   EXPECT_TRUE(timer->IsRunning());
-  EXPECT_EQ(window1, GetLongPressAffordanceTarget());
+  EXPECT_EQ(window1.get(), GetLongPressAffordanceTarget());
 
   // Force timeout so that the affordance animation can start.
   timer->user_task().Run();
diff --git a/ash/wm/system_modal_container_layout_manager_unittest.cc b/ash/wm/system_modal_container_layout_manager_unittest.cc
index 7273f6f..1d2eaa7 100644
--- a/ash/wm/system_modal_container_layout_manager_unittest.cc
+++ b/ash/wm/system_modal_container_layout_manager_unittest.cc
@@ -275,7 +275,7 @@ TEST_F(SystemModalContainerLayoutManagerTest, ModalNonTransient) {
 
   EXPECT_TRUE(wm::IsActiveWindow(t2));
 
-  EXPECT_EQ(t1, ::wm::GetTransientParent(t2));
+  EXPECT_EQ(t1.get(), ::wm::GetTransientParent(t2));
   EXPECT_EQ(GetModalContainer(), t2->parent());
 
   // t2 should still be active, even after clicking on t1.
diff --git a/ash/wm/workspace/workspace_window_resizer_unittest.cc b/ash/wm/workspace/workspace_window_resizer_unittest.cc
index 359d0b6..0d8efc3 100644
--- a/ash/wm/workspace/workspace_window_resizer_unittest.cc
+++ b/ash/wm/workspace/workspace_window_resizer_unittest.cc
@@ -126,7 +126,7 @@ class WorkspaceWindowResizerTest : public test::AshTestBase {
     const aura::Window::Windows& windows = parent->children();
     for (aura::Window::Windows::const_reverse_iterator i = windows.rbegin();
          i != windows.rend(); ++i) {
-      if (*i == window_ || *i == window2_ || *i == window3_) {
+      if (*i == window_.get() || *i == window2_.get() || *i == window3_.get()) {
         if (!result.empty())
           result += " ";
         result += base::IntToString((*i)->id());
diff --git a/base/memory/scoped_ptr.h b/base/memory/scoped_ptr.h
index c4d75a4..291d9b3 100644
--- a/base/memory/scoped_ptr.h
+++ b/base/memory/scoped_ptr.h
@@ -325,7 +325,7 @@ class scoped_ptr {
   scoped_ptr(element_type* p, const D& d) : impl_(p, d) {}
 
   // Constructor.  Allows construction from a nullptr.
-  scoped_ptr(decltype(nullptr)) : impl_(nullptr) {}
+  scoped_ptr(std::nullptr_t) : impl_(nullptr) {}
 
   // Constructor.  Allows construction from a scoped_ptr rvalue for a
   // convertible type and deleter.
@@ -362,7 +362,7 @@ class scoped_ptr {
 
   // operator=.  Allows assignment from a nullptr. Deletes the currently owned
   // object, if any.
-  scoped_ptr& operator=(decltype(nullptr)) {
+  scoped_ptr& operator=(std::nullptr_t) {
     reset();
     return *this;
   }
@@ -403,12 +403,6 @@ class scoped_ptr {
     return impl_.get() ? &scoped_ptr::impl_ : nullptr;
   }
 
-  // Comparison operators.
-  // These return whether two scoped_ptr refer to the same object, not just to
-  // two different but equal objects.
-  bool operator==(const element_type* p) const { return impl_.get() == p; }
-  bool operator!=(const element_type* p) const { return impl_.get() != p; }
-
   // Swap two scoped pointers.
   void swap(scoped_ptr& p2) {
     impl_.swap(p2.impl_);
@@ -429,13 +423,6 @@ class scoped_ptr {
 
   // Forbidden for API compatibility with std::unique_ptr.
   explicit scoped_ptr(int disallow_construction_from_null);
-
-  // Forbid comparison of scoped_ptr types.  If U != T, it totally
-  // doesn't make sense, and if U == T, it still doesn't make sense
-  // because you should never have the same object owned by two different
-  // scoped_ptrs.
-  template <class U> bool operator==(scoped_ptr<U> const& p2) const;
-  template <class U> bool operator!=(scoped_ptr<U> const& p2) const;
 };
 
 template <class T, class D>
@@ -464,7 +451,7 @@ class scoped_ptr<T[], D> {
   explicit scoped_ptr(element_type* array) : impl_(array) {}
 
   // Constructor.  Allows construction from a nullptr.
-  scoped_ptr(decltype(nullptr)) : impl_(nullptr) {}
+  scoped_ptr(std::nullptr_t) : impl_(nullptr) {}
 
   // Constructor.  Allows construction from a scoped_ptr rvalue.
   scoped_ptr(scoped_ptr&& other) : impl_(&other.impl_) {}
@@ -477,7 +464,7 @@ class scoped_ptr<T[], D> {
 
   // operator=.  Allows assignment from a nullptr. Deletes the currently owned
   // array, if any.
-  scoped_ptr& operator=(decltype(nullptr)) {
+  scoped_ptr& operator=(std::nullptr_t) {
     reset();
     return *this;
   }
@@ -508,12 +495,6 @@ class scoped_ptr<T[], D> {
     return impl_.get() ? &scoped_ptr::impl_ : nullptr;
   }
 
-  // Comparison operators.
-  // These return whether two scoped_ptr refer to the same object, not just to
-  // two different but equal objects.
-  bool operator==(element_type* array) const { return impl_.get() == array; }
-  bool operator!=(element_type* array) const { return impl_.get() != array; }
-
   // Swap two scoped pointers.
   void swap(scoped_ptr& p2) {
     impl_.swap(p2.impl_);
@@ -546,13 +527,6 @@ class scoped_ptr<T[], D> {
   // reasons as the constructor above.
   template <typename U> void reset(U* array);
   void reset(int disallow_reset_from_null);
-
-  // Forbid comparison of scoped_ptr types.  If U != T, it totally
-  // doesn't make sense, and if U == T, it still doesn't make sense
-  // because you should never have the same object owned by two different
-  // scoped_ptrs.
-  template <class U> bool operator==(scoped_ptr<U> const& p2) const;
-  template <class U> bool operator!=(scoped_ptr<U> const& p2) const;
 };
 
 // Free functions
@@ -561,14 +535,82 @@ void swap(scoped_ptr<T, D>& p1, scoped_ptr<T, D>& p2) {
   p1.swap(p2);
 }
 
+template <class T1, class D1, class T2, class D2>
+bool operator==(const scoped_ptr<T1, D1>& p1, const scoped_ptr<T2, D2>& p2) {
+  return p1.get() == p2.get();
+}
+template <class T, class D>
+bool operator==(const scoped_ptr<T, D>& p, std::nullptr_t) {
+  return p.get() == nullptr;
+}
+template <class T, class D>
+bool operator==(std::nullptr_t, const scoped_ptr<T, D>& p) {
+  return p.get() == nullptr;
+}
+
+template <class T1, class D1, class T2, class D2>
+bool operator!=(const scoped_ptr<T1, D1>& p1, const scoped_ptr<T2, D2>& p2) {
+  return !(p1 == p2);
+}
+template <class T, class D>
+bool operator!=(const scoped_ptr<T, D>& p, std::nullptr_t) {
+  return !(p == nullptr);
+}
+template <class T, class D>
+bool operator!=(std::nullptr_t, const scoped_ptr<T, D>& p) {
+  return !(p == nullptr);
+}
+
+template <class T1, class D1, class T2, class D2>
+bool operator<(const scoped_ptr<T1, D1>& p1, const scoped_ptr<T2, D2>& p2) {
+  return p1.get() < p2.get();
+}
+template <class T, class D>
+bool operator<(const scoped_ptr<T, D>& p, std::nullptr_t) {
+  return p.get() < nullptr;
+}
+template <class T, class D>
+bool operator<(std::nullptr_t, const scoped_ptr<T, D>& p) {
+  return nullptr < p.get();
+}
+
+template <class T1, class D1, class T2, class D2>
+bool operator>(const scoped_ptr<T1, D1>& p1, const scoped_ptr<T2, D2>& p2) {
+  return p2 < p1;
+}
+template <class T, class D>
+bool operator>(const scoped_ptr<T, D>& p, std::nullptr_t) {
+  return nullptr < p;
+}
 template <class T, class D>
-bool operator==(T* p1, const scoped_ptr<T, D>& p2) {
-  return p1 == p2.get();
+bool operator>(std::nullptr_t, const scoped_ptr<T, D>& p) {
+  return p < nullptr;
 }
 
+template <class T1, class D1, class T2, class D2>
+bool operator<=(const scoped_ptr<T1, D1>& p1, const scoped_ptr<T2, D2>& p2) {
+  return !(p1 > p2);
+}
+template <class T, class D>
+bool operator<=(const scoped_ptr<T, D>& p, std::nullptr_t) {
+  return !(p > nullptr);
+}
+template <class T, class D>
+bool operator<=(std::nullptr_t, const scoped_ptr<T, D>& p) {
+  return !(nullptr > p);
+}
+
+template <class T1, class D1, class T2, class D2>
+bool operator>=(const scoped_ptr<T1, D1>& p1, const scoped_ptr<T2, D2>& p2) {
+  return !(p1 < p2);
+}
+template <class T, class D>
+bool operator>=(const scoped_ptr<T, D>& p, std::nullptr_t) {
+  return !(p < nullptr);
+}
 template <class T, class D>
-bool operator!=(T* p1, const scoped_ptr<T, D>& p2) {
-  return p1 != p2.get();
+bool operator>=(std::nullptr_t, const scoped_ptr<T, D>& p) {
+  return !(nullptr < p);
 }
 
 // A function to convert T* into scoped_ptr<T>
diff --git a/base/memory/scoped_ptr_unittest.cc b/base/memory/scoped_ptr_unittest.cc
index eb5bf00..ad49f4f 100644
--- a/base/memory/scoped_ptr_unittest.cc
+++ b/base/memory/scoped_ptr_unittest.cc
@@ -146,25 +146,25 @@ TEST(ScopedPtrTest, ScopedPtr) {
   }
   EXPECT_EQ(0, constructed);
 
-  // Test swap(), == and !=
+  // Test swap().
   {
     scoped_ptr<ConDecLogger> scoper1;
     scoped_ptr<ConDecLogger> scoper2;
-    EXPECT_TRUE(scoper1 == scoper2.get());
-    EXPECT_FALSE(scoper1 != scoper2.get());
+    EXPECT_TRUE(scoper1.get() == scoper2.get());
+    EXPECT_FALSE(scoper1.get() != scoper2.get());
 
     ConDecLogger* logger = new ConDecLogger(&constructed);
     scoper1.reset(logger);
     EXPECT_EQ(logger, scoper1.get());
     EXPECT_FALSE(scoper2.get());
-    EXPECT_FALSE(scoper1 == scoper2.get());
-    EXPECT_TRUE(scoper1 != scoper2.get());
+    EXPECT_FALSE(scoper1.get() == scoper2.get());
+    EXPECT_TRUE(scoper1.get() != scoper2.get());
 
     scoper2.swap(scoper1);
     EXPECT_EQ(logger, scoper2.get());
     EXPECT_FALSE(scoper1.get());
-    EXPECT_FALSE(scoper1 == scoper2.get());
-    EXPECT_TRUE(scoper1 != scoper2.get());
+    EXPECT_FALSE(scoper1.get() == scoper2.get());
+    EXPECT_TRUE(scoper1.get() != scoper2.get());
   }
   EXPECT_EQ(0, constructed);
 }
@@ -327,12 +327,12 @@ TEST(ScopedPtrTest, ScopedPtrWithArray) {
   }
   EXPECT_EQ(0, constructed);
 
-  // Test swap(), ==, !=, and type-safe Boolean.
+  // Test swap() and type-safe Boolean.
   {
     scoped_ptr<ConDecLogger[]> scoper1;
     scoped_ptr<ConDecLogger[]> scoper2;
-    EXPECT_TRUE(scoper1 == scoper2.get());
-    EXPECT_FALSE(scoper1 != scoper2.get());
+    EXPECT_TRUE(scoper1.get() == scoper2.get());
+    EXPECT_FALSE(scoper1.get() != scoper2.get());
 
     ConDecLogger* loggers = new ConDecLogger[kNumLoggers];
     for (int i = 0; i < kNumLoggers; ++i) {
@@ -343,14 +343,14 @@ TEST(ScopedPtrTest, ScopedPtrWithArray) {
     EXPECT_EQ(loggers, scoper1.get());
     EXPECT_FALSE(scoper2);
     EXPECT_FALSE(scoper2.get());
-    EXPECT_FALSE(scoper1 == scoper2.get());
-    EXPECT_TRUE(scoper1 != scoper2.get());
+    EXPECT_FALSE(scoper1.get() == scoper2.get());
+    EXPECT_TRUE(scoper1.get() != scoper2.get());
 
     scoper2.swap(scoper1);
     EXPECT_EQ(loggers, scoper2.get());
     EXPECT_FALSE(scoper1.get());
-    EXPECT_FALSE(scoper1 == scoper2.get());
-    EXPECT_TRUE(scoper1 != scoper2.get());
+    EXPECT_FALSE(scoper1.get() == scoper2.get());
+    EXPECT_TRUE(scoper1.get() != scoper2.get());
   }
   EXPECT_EQ(0, constructed);
 
@@ -549,28 +549,28 @@ TEST(ScopedPtrTest, CustomDeleter) {
   EXPECT_EQ(1, deletes);
   EXPECT_EQ(3, alternate_deletes);
 
-  // Test swap(), ==, !=, and type-safe Boolean.
+  // Test swap(), and type-safe Boolean.
   {
     scoped_ptr<double, CountingDeleter> scoper1(NULL,
                                                 CountingDeleter(&deletes));
     scoped_ptr<double, CountingDeleter> scoper2(NULL,
                                                 CountingDeleter(&deletes));
-    EXPECT_TRUE(scoper1 == scoper2.get());
-    EXPECT_FALSE(scoper1 != scoper2.get());
+    EXPECT_TRUE(scoper1.get() == scoper2.get());
+    EXPECT_FALSE(scoper1.get() != scoper2.get());
 
     scoper1.reset(&dummy_value);
     EXPECT_TRUE(scoper1);
     EXPECT_EQ(&dummy_value, scoper1.get());
     EXPECT_FALSE(scoper2);
     EXPECT_FALSE(scoper2.get());
-    EXPECT_FALSE(scoper1 == scoper2.get());
-    EXPECT_TRUE(scoper1 != scoper2.get());
+    EXPECT_FALSE(scoper1.get() == scoper2.get());
+    EXPECT_TRUE(scoper1.get() != scoper2.get());
 
     scoper2.swap(scoper1);
     EXPECT_EQ(&dummy_value, scoper2.get());
     EXPECT_FALSE(scoper1.get());
-    EXPECT_FALSE(scoper1 == scoper2.get());
-    EXPECT_TRUE(scoper1 != scoper2.get());
+    EXPECT_FALSE(scoper1.get() == scoper2.get());
+    EXPECT_TRUE(scoper1.get() != scoper2.get());
   }
 }
 
@@ -726,3 +726,149 @@ TEST(ScopedPtrTest, ReferenceCycle) {
   a->b->a.reset(a);
   a->~StructA();
 }
+
+TEST(ScopedPtrTest, Operators) {
+  struct Parent {};
+  struct Child : public Parent {};
+
+  scoped_ptr<Parent> p(new Parent);
+  scoped_ptr<Parent> p2(new Parent);
+  scoped_ptr<Child> c(new Child);
+  scoped_ptr<Parent> pnull;
+
+  // Operator==.
+  EXPECT_TRUE(p == p);
+  EXPECT_FALSE(p == c);
+  EXPECT_FALSE(p == p2);
+  EXPECT_FALSE(p == pnull);
+
+  EXPECT_FALSE(p == nullptr);
+  EXPECT_FALSE(nullptr == p);
+  EXPECT_TRUE(pnull == nullptr);
+  EXPECT_TRUE(nullptr == pnull);
+
+  // Operator!=.
+  EXPECT_FALSE(p != p);
+  EXPECT_TRUE(p != c);
+  EXPECT_TRUE(p != p2);
+  EXPECT_TRUE(p != pnull);
+
+  EXPECT_TRUE(p != nullptr);
+  EXPECT_TRUE(nullptr != p);
+  EXPECT_FALSE(pnull != nullptr);
+  EXPECT_FALSE(nullptr != pnull);
+
+  // Compare two scoped_ptr<T>.
+  EXPECT_EQ(p.get() < p2.get(), p < p2);
+  EXPECT_EQ(p.get() <= p2.get(), p <= p2);
+  EXPECT_EQ(p.get() > p2.get(), p > p2);
+  EXPECT_EQ(p.get() >= p2.get(), p >= p2);
+  EXPECT_EQ(p2.get() < p.get(), p2 < p);
+  EXPECT_EQ(p2.get() <= p.get(), p2 <= p);
+  EXPECT_EQ(p2.get() > p.get(), p2 > p);
+  EXPECT_EQ(p2.get() >= p.get(), p2 >= p);
+
+  // And convertible scoped_ptr<T> and scoped_ptr<U>.
+  EXPECT_EQ(p.get() < c.get(), p < c);
+  EXPECT_EQ(p.get() <= c.get(), p <= c);
+  EXPECT_EQ(p.get() > c.get(), p > c);
+  EXPECT_EQ(p.get() >= c.get(), p >= c);
+  EXPECT_EQ(c.get() < p.get(), c < p);
+  EXPECT_EQ(c.get() <= p.get(), c <= p);
+  EXPECT_EQ(c.get() > p.get(), c > p);
+  EXPECT_EQ(c.get() >= p.get(), c >= p);
+
+  // Compare to nullptr.
+  EXPECT_TRUE(p > nullptr);
+  EXPECT_FALSE(nullptr > p);
+  EXPECT_FALSE(pnull > nullptr);
+  EXPECT_FALSE(nullptr > pnull);
+
+  EXPECT_TRUE(p >= nullptr);
+  EXPECT_FALSE(nullptr >= p);
+  EXPECT_TRUE(pnull >= nullptr);
+  EXPECT_TRUE(nullptr >= pnull);
+
+  EXPECT_FALSE(p < nullptr);
+  EXPECT_TRUE(nullptr < p);
+  EXPECT_FALSE(pnull < nullptr);
+  EXPECT_FALSE(nullptr < pnull);
+
+  EXPECT_FALSE(p <= nullptr);
+  EXPECT_TRUE(nullptr <= p);
+  EXPECT_TRUE(pnull <= nullptr);
+  EXPECT_TRUE(nullptr <= pnull);
+};
+
+TEST(ScopedPtrTest, ArrayOperators) {
+  struct Parent {};
+  struct Child : public Parent {};
+
+  scoped_ptr<Parent[]> p(new Parent[1]);
+  scoped_ptr<Parent[]> p2(new Parent[1]);
+  scoped_ptr<Child[]> c(new Child[1]);
+  scoped_ptr<Parent[]> pnull;
+
+  // Operator==.
+  EXPECT_TRUE(p == p);
+  EXPECT_FALSE(p == c);
+  EXPECT_FALSE(p == p2);
+  EXPECT_FALSE(p == pnull);
+
+  EXPECT_FALSE(p == nullptr);
+  EXPECT_FALSE(nullptr == p);
+  EXPECT_TRUE(pnull == nullptr);
+  EXPECT_TRUE(nullptr == pnull);
+
+  // Operator!=.
+  EXPECT_FALSE(p != p);
+  EXPECT_TRUE(p != c);
+  EXPECT_TRUE(p != p2);
+  EXPECT_TRUE(p != pnull);
+
+  EXPECT_TRUE(p != nullptr);
+  EXPECT_TRUE(nullptr != p);
+  EXPECT_FALSE(pnull != nullptr);
+  EXPECT_FALSE(nullptr != pnull);
+
+  // Compare two scoped_ptr<T>.
+  EXPECT_EQ(p.get() < p2.get(), p < p2);
+  EXPECT_EQ(p.get() <= p2.get(), p <= p2);
+  EXPECT_EQ(p.get() > p2.get(), p > p2);
+  EXPECT_EQ(p.get() >= p2.get(), p >= p2);
+  EXPECT_EQ(p2.get() < p.get(), p2 < p);
+  EXPECT_EQ(p2.get() <= p.get(), p2 <= p);
+  EXPECT_EQ(p2.get() > p.get(), p2 > p);
+  EXPECT_EQ(p2.get() >= p.get(), p2 >= p);
+
+  // And convertible scoped_ptr<T> and scoped_ptr<U>.
+  EXPECT_EQ(p.get() < c.get(), p < c);
+  EXPECT_EQ(p.get() <= c.get(), p <= c);
+  EXPECT_EQ(p.get() > c.get(), p > c);
+  EXPECT_EQ(p.get() >= c.get(), p >= c);
+  EXPECT_EQ(c.get() < p.get(), c < p);
+  EXPECT_EQ(c.get() <= p.get(), c <= p);
+  EXPECT_EQ(c.get() > p.get(), c > p);
+  EXPECT_EQ(c.get() >= p.get(), c >= p);
+
+  // Compare to nullptr.
+  EXPECT_TRUE(p > nullptr);
+  EXPECT_FALSE(nullptr > p);
+  EXPECT_FALSE(pnull > nullptr);
+  EXPECT_FALSE(nullptr > pnull);
+
+  EXPECT_TRUE(p >= nullptr);
+  EXPECT_FALSE(nullptr >= p);
+  EXPECT_TRUE(pnull >= nullptr);
+  EXPECT_TRUE(nullptr >= pnull);
+
+  EXPECT_FALSE(p < nullptr);
+  EXPECT_TRUE(nullptr < p);
+  EXPECT_FALSE(pnull < nullptr);
+  EXPECT_FALSE(nullptr < pnull);
+
+  EXPECT_FALSE(p <= nullptr);
+  EXPECT_TRUE(nullptr <= p);
+  EXPECT_TRUE(pnull <= nullptr);
+  EXPECT_TRUE(nullptr <= pnull);
+}
diff --git a/base/trace_event/memory_dump_manager_unittest.cc b/base/trace_event/memory_dump_manager_unittest.cc
index 75a6c26..d32bdaa 100644
--- a/base/trace_event/memory_dump_manager_unittest.cc
+++ b/base/trace_event/memory_dump_manager_unittest.cc
@@ -102,7 +102,7 @@ class MemoryDumpManagerTest : public testing::Test {
     message_loop_.reset(new MessageLoop());
     mdm_.reset(new MemoryDumpManager());
     MemoryDumpManager::SetInstanceForTesting(mdm_.get());
-    ASSERT_EQ(mdm_, MemoryDumpManager::GetInstance());
+    ASSERT_EQ(mdm_.get(), MemoryDumpManager::GetInstance());
     delegate_.reset(new MemoryDumpManagerDelegateForTesting);
   }
 
diff --git a/base/tracked_objects_unittest.cc b/base/tracked_objects_unittest.cc
index cdbf9ac..09d7653 100644
--- a/base/tracked_objects_unittest.cc
+++ b/base/tracked_objects_unittest.cc
@@ -240,7 +240,7 @@ TEST_F(TrackedObjectsTest, DeathDataTestRecordDeath) {
   ThreadData::InitializeAndSetTrackingStatus(ThreadData::PROFILING_ACTIVE);
 
   scoped_ptr<DeathData> data(new DeathData());
-  ASSERT_NE(data, reinterpret_cast<DeathData*>(NULL));
+  ASSERT_NE(data, nullptr);
   EXPECT_EQ(data->run_duration_sum(), 0);
   EXPECT_EQ(data->run_duration_max(), 0);
   EXPECT_EQ(data->run_duration_sample(), 0);
@@ -279,7 +279,7 @@ TEST_F(TrackedObjectsTest, DeathDataTest2Phases) {
   ThreadData::InitializeAndSetTrackingStatus(ThreadData::PROFILING_ACTIVE);
 
   scoped_ptr<DeathData> data(new DeathData());
-  ASSERT_NE(data, reinterpret_cast<DeathData*>(NULL));
+  ASSERT_NE(data, nullptr);
 
   int32 run_ms = 42;
   int32 queue_ms = 8;
diff --git a/blimp/engine/browser/blimp_engine_session.cc b/blimp/engine/browser/blimp_engine_session.cc
index 79c1a40..f65706a 100644
--- a/blimp/engine/browser/blimp_engine_session.cc
+++ b/blimp/engine/browser/blimp_engine_session.cc
@@ -225,7 +225,7 @@ void BlimpEngineSession::RequestToLockMouse(content::WebContents* web_contents,
 }
 
 void BlimpEngineSession::CloseContents(content::WebContents* source) {
-  if (source == web_contents_)
+  if (source == web_contents_.get())
     web_contents_.reset();
 }
 
diff --git a/cc/input/scroll_state_unittest.cc b/cc/input/scroll_state_unittest.cc
index 314f4f3..67c0124 100644
--- a/cc/input/scroll_state_unittest.cc
+++ b/cc/input/scroll_state_unittest.cc
@@ -66,7 +66,7 @@ TEST_F(ScrollStateTest, CurrentNativeScrollingScrollable) {
   scoped_ptr<LayerImpl> layer_impl =
       LayerImpl::Create(host_impl.active_tree(), 1);
   scrollState.set_current_native_scrolling_layer(layer_impl.get());
-  EXPECT_EQ(layer_impl, scrollState.current_native_scrolling_layer());
+  EXPECT_EQ(layer_impl.get(), scrollState.current_native_scrolling_layer());
 }
 
 TEST_F(ScrollStateTest, FullyConsumed) {
diff --git a/cc/raster/one_copy_tile_task_worker_pool.cc b/cc/raster/one_copy_tile_task_worker_pool.cc
index 5aa1aaa..dc1d118 100644
--- a/cc/raster/one_copy_tile_task_worker_pool.cc
+++ b/cc/raster/one_copy_tile_task_worker_pool.cc
@@ -540,10 +540,14 @@ bool OneCopyTileTaskWorkerPool::OnMemoryDump(
     base::trace_event::ProcessMemoryDump* pmd) {
   base::AutoLock lock(lock_);
 
-  for (const auto& buffer : buffers_) {
+  for (const auto* buffer : buffers_) {
+    auto in_free_buffers =
+        std::find_if(free_buffers_.begin(), free_buffers_.end(),
+                     [buffer](const scoped_ptr<StagingBuffer>& b) {
+                       return b.get() == buffer;
+                     });
     buffer->OnMemoryDump(pmd, buffer->format,
-                         std::find(free_buffers_.begin(), free_buffers_.end(),
-                                   buffer) != free_buffers_.end());
+                         in_free_buffers != free_buffers_.end());
   }
 
   return true;
diff --git a/cc/trees/damage_tracker_unittest.cc b/cc/trees/damage_tracker_unittest.cc
index 949baa2..7dbfa10 100644
--- a/cc/trees/damage_tracker_unittest.cc
+++ b/cc/trees/damage_tracker_unittest.cc
@@ -1384,7 +1384,7 @@ TEST_F(DamageTrackerTest, VerifyDamageForEmptyLayerList) {
   root->SetHasRenderSurface(true);
   root->draw_properties().render_target = root.get();
 
-  ASSERT_TRUE(root == root->render_target());
+  ASSERT_EQ(root.get(), root->render_target());
   RenderSurfaceImpl* target_surface = root->render_surface();
 
   LayerImplList empty_list;
diff --git a/cc/trees/layer_tree_host_impl.cc b/cc/trees/layer_tree_host_impl.cc
index 6834c22..fcc98b5 100644
--- a/cc/trees/layer_tree_host_impl.cc
+++ b/cc/trees/layer_tree_host_impl.cc
@@ -899,7 +899,7 @@ DrawResult LayerTreeHostImpl::CalculateRenderPasses(
           it->draw_properties().occlusion_in_content_space.IsOccluded(
               it->visible_layer_rect());
       if (!occluded && it->WillDraw(draw_mode, resource_provider_.get())) {
-        DCHECK_EQ(active_tree_, it->layer_tree_impl());
+        DCHECK_EQ(active_tree_.get(), it->layer_tree_impl());
 
         frame->will_draw_layers.push_back(*it);
 
diff --git a/chrome/browser/chromeos/platform_keys/platform_keys_nss.cc b/chrome/browser/chromeos/platform_keys/platform_keys_nss.cc
index 937390e..0bdb44b 100644
--- a/chrome/browser/chromeos/platform_keys/platform_keys_nss.cc
+++ b/chrome/browser/chromeos/platform_keys/platform_keys_nss.cc
@@ -633,7 +633,7 @@ void ImportCertificateWithDB(scoped_ptr<ImportCertificateState> state,
   // Check that the private key is in the correct slot.
   PK11SlotInfo* slot =
       PK11_KeyForCertExists(state->certificate_->os_cert_handle(), NULL, NULL);
-  if (slot != state->slot_) {
+  if (slot != state->slot_.get()) {
     state->OnError(FROM_HERE, kErrorKeyNotFound);
     return;
   }
diff --git a/chrome/browser/chromeos/policy/consumer_enrollment_handler.cc b/chrome/browser/chromeos/policy/consumer_enrollment_handler.cc
index 25cfdb5..2b2e994 100644
--- a/chrome/browser/chromeos/policy/consumer_enrollment_handler.cc
+++ b/chrome/browser/chromeos/policy/consumer_enrollment_handler.cc
@@ -63,7 +63,7 @@ void ConsumerEnrollmentHandler::OnGetTokenSuccess(
       const OAuth2TokenService::Request* request,
       const std::string& access_token,
       const base::Time& expiration_time) {
-  DCHECK_EQ(token_request_, request);
+  DCHECK_EQ(token_request_.get(), request);
   base::MessageLoop::current()->DeleteSoon(FROM_HERE, token_request_.release());
 
   OnOwnerAccessTokenAvailable(access_token);
@@ -72,7 +72,7 @@ void ConsumerEnrollmentHandler::OnGetTokenSuccess(
 void ConsumerEnrollmentHandler::OnGetTokenFailure(
       const OAuth2TokenService::Request* request,
       const GoogleServiceAuthError& error) {
-  DCHECK_EQ(token_request_, request);
+  DCHECK_EQ(token_request_.get(), request);
   base::MessageLoop::current()->DeleteSoon(FROM_HERE, token_request_.release());
 
   LOG(ERROR) << "Failed to get the access token: " << error.ToString();
diff --git a/chrome/browser/prerender/prerender_manager.cc b/chrome/browser/prerender/prerender_manager.cc
index bd9b253..59ace6e 100644
--- a/chrome/browser/prerender/prerender_manager.cc
+++ b/chrome/browser/prerender/prerender_manager.cc
@@ -134,19 +134,19 @@ class PrerenderManager::OnCloseWebContentsDeleter
   }
 
   void CloseContents(WebContents* source) override {
-    DCHECK_EQ(tab_, source);
+    DCHECK_EQ(tab_.get(), source);
     ScheduleWebContentsForDeletion(false);
   }
 
   void SwappedOut(WebContents* source) override {
-    DCHECK_EQ(tab_, source);
+    DCHECK_EQ(tab_.get(), source);
     ScheduleWebContentsForDeletion(false);
   }
 
   bool ShouldSuppressDialogs(WebContents* source) override {
     // Use this as a proxy for getting statistics on how often we fail to honor
     // the beforeunload event.
-    DCHECK_EQ(tab_, source);
+    DCHECK_EQ(tab_.get(), source);
     suppressed_dialog_ = true;
     return true;
   }
@@ -824,7 +824,7 @@ PrerenderManager::PrerenderData::PrerenderData(PrerenderManager* manager,
       contents_(contents),
       handle_count_(0),
       expiry_time_(expiry_time) {
-  DCHECK_NE(static_cast<PrerenderContents*>(NULL), contents_);
+  DCHECK(contents_);
 }
 
 PrerenderManager::PrerenderData::~PrerenderData() {
@@ -841,7 +841,7 @@ void PrerenderManager::PrerenderData::MakeIntoMatchCompleteReplacement() {
 }
 
 void PrerenderManager::PrerenderData::OnHandleCreated(PrerenderHandle* handle) {
-  DCHECK_NE(static_cast<PrerenderContents*>(NULL), contents_);
+  DCHECK(contents_);
   ++handle_count_;
   contents_->AddObserver(handle);
 }
@@ -849,7 +849,7 @@ void PrerenderManager::PrerenderData::OnHandleCreated(PrerenderHandle* handle) {
 void PrerenderManager::PrerenderData::OnHandleNavigatedAway(
     PrerenderHandle* handle) {
   DCHECK_LT(0, handle_count_);
-  DCHECK_NE(static_cast<PrerenderContents*>(NULL), contents_);
+  DCHECK(contents_);
   if (abandon_time_.is_null())
     abandon_time_ = base::TimeTicks::Now();
   // We intentionally don't decrement the handle count here, so that the
@@ -860,7 +860,7 @@ void PrerenderManager::PrerenderData::OnHandleNavigatedAway(
 void PrerenderManager::PrerenderData::OnHandleCanceled(
     PrerenderHandle* handle) {
   DCHECK_LT(0, handle_count_);
-  DCHECK_NE(static_cast<PrerenderContents*>(NULL), contents_);
+  DCHECK(contents_);
 
   if (--handle_count_ == 0) {
     // This will eventually remove this object from active_prerenders_.
diff --git a/chrome/browser/profile_resetter/profile_resetter_unittest.cc b/chrome/browser/profile_resetter/profile_resetter_unittest.cc
index 50420ab..b394a89 100644
--- a/chrome/browser/profile_resetter/profile_resetter_unittest.cc
+++ b/chrome/browser/profile_resetter/profile_resetter_unittest.cc
@@ -742,18 +742,18 @@ TEST_F(PinnedTabsResetTest, ResetPinnedTabs) {
   tab_strip_model->AppendWebContents(contents1.get(), true);
   tab_strip_model->SetTabPinned(3, true);
 
-  EXPECT_EQ(contents2, tab_strip_model->GetWebContentsAt(0));
-  EXPECT_EQ(contents1, tab_strip_model->GetWebContentsAt(1));
-  EXPECT_EQ(contents4, tab_strip_model->GetWebContentsAt(2));
-  EXPECT_EQ(contents3, tab_strip_model->GetWebContentsAt(3));
+  EXPECT_EQ(contents2.get(), tab_strip_model->GetWebContentsAt(0));
+  EXPECT_EQ(contents1.get(), tab_strip_model->GetWebContentsAt(1));
+  EXPECT_EQ(contents4.get(), tab_strip_model->GetWebContentsAt(2));
+  EXPECT_EQ(contents3.get(), tab_strip_model->GetWebContentsAt(3));
   EXPECT_EQ(2, tab_strip_model->IndexOfFirstNonPinnedTab());
 
   ResetAndWait(ProfileResetter::PINNED_TABS);
 
-  EXPECT_EQ(contents2, tab_strip_model->GetWebContentsAt(0));
-  EXPECT_EQ(contents1, tab_strip_model->GetWebContentsAt(1));
-  EXPECT_EQ(contents4, tab_strip_model->GetWebContentsAt(2));
-  EXPECT_EQ(contents3, tab_strip_model->GetWebContentsAt(3));
+  EXPECT_EQ(contents2.get(), tab_strip_model->GetWebContentsAt(0));
+  EXPECT_EQ(contents1.get(), tab_strip_model->GetWebContentsAt(1));
+  EXPECT_EQ(contents4.get(), tab_strip_model->GetWebContentsAt(2));
+  EXPECT_EQ(contents3.get(), tab_strip_model->GetWebContentsAt(3));
   EXPECT_EQ(0, tab_strip_model->IndexOfFirstNonPinnedTab());
 }
 
diff --git a/chrome/browser/safe_browsing/client_side_model_loader.cc b/chrome/browser/safe_browsing/client_side_model_loader.cc
index 863f820..16c0f62 100644
--- a/chrome/browser/safe_browsing/client_side_model_loader.cc
+++ b/chrome/browser/safe_browsing/client_side_model_loader.cc
@@ -119,7 +119,7 @@ void ModelLoader::StartFetch() {
 }
 
 void ModelLoader::OnURLFetchComplete(const net::URLFetcher* source) {
-  DCHECK_EQ(fetcher_, source);
+  DCHECK_EQ(fetcher_.get(), source);
   DCHECK_EQ(url_, source->GetURL());
 
   std::string data;
diff --git a/chrome/browser/ui/app_list/search/launcher_search/launcher_search_icon_image_loader_impl.cc b/chrome/browser/ui/app_list/search/launcher_search/launcher_search_icon_image_loader_impl.cc
index 6664837..2286f56 100644
--- a/chrome/browser/ui/app_list/search/launcher_search/launcher_search_icon_image_loader_impl.cc
+++ b/chrome/browser/ui/app_list/search/launcher_search/launcher_search_icon_image_loader_impl.cc
@@ -58,7 +58,7 @@ void LauncherSearchIconImageLoaderImpl::LoadIconResourceFromExtension() {
 
 void LauncherSearchIconImageLoaderImpl::OnExtensionIconImageChanged(
     extensions::IconImage* image) {
-  DCHECK_EQ(extension_icon_image_, image);
+  DCHECK_EQ(extension_icon_image_.get(), image);
   OnExtensionIconChanged(extension_icon_image_->image_skia());
 }
 
diff --git a/chrome/browser/ui/app_list/search/people/people_provider.cc b/chrome/browser/ui/app_list/search/people/people_provider.cc
index 1677b18..92d626d 100644
--- a/chrome/browser/ui/app_list/search/people/people_provider.cc
+++ b/chrome/browser/ui/app_list/search/people/people_provider.cc
@@ -103,7 +103,7 @@ void PeopleProvider::OnGetTokenSuccess(
     const OAuth2TokenService::Request* request,
     const std::string& access_token,
     const base::Time& expiration_time) {
-  DCHECK_EQ(access_token_request_, request);
+  DCHECK_EQ(access_token_request_.get(), request);
   access_token_request_.reset();
   access_token_ = access_token;
   StartQuery();
@@ -112,7 +112,7 @@ void PeopleProvider::OnGetTokenSuccess(
 void PeopleProvider::OnGetTokenFailure(
     const OAuth2TokenService::Request* request,
     const GoogleServiceAuthError& error) {
-  DCHECK_EQ(access_token_request_, request);
+  DCHECK_EQ(access_token_request_.get(), request);
   access_token_request_.reset();
 }
 
diff --git a/chrome/browser/ui/cocoa/browser_window_controller.mm b/chrome/browser/ui/cocoa/browser_window_controller.mm
index 12e4f0b..6ea2239 100644
--- a/chrome/browser/ui/cocoa/browser_window_controller.mm
+++ b/chrome/browser/ui/cocoa/browser_window_controller.mm
@@ -609,7 +609,7 @@ using content::WebContents;
 
 // Called right after our window became the main window.
 - (void)windowDidBecomeMain:(NSNotification*)notification {
-  if (chrome::GetLastActiveBrowser() != browser_) {
+  if (chrome::GetLastActiveBrowser() != browser_.get()) {
     BrowserList::SetLastActive(browser_.get());
   }
   // Always saveWindowPositionIfNeeded when becoming main, not just
diff --git a/chrome/browser/ui/cocoa/browser_window_controller_private.mm b/chrome/browser/ui/cocoa/browser_window_controller_private.mm
index 7d04649..73c8495 100644
--- a/chrome/browser/ui/cocoa/browser_window_controller_private.mm
+++ b/chrome/browser/ui/cocoa/browser_window_controller_private.mm
@@ -157,7 +157,7 @@ void RecordFullscreenStyle(FullscreenStyle style) {
 
   // Only save main window information to preferences.
   PrefService* prefs = browser_->profile()->GetPrefs();
-  if (!prefs || browser_ != chrome::GetLastActiveBrowser())
+  if (!prefs || browser_.get() != chrome::GetLastActiveBrowser())
     return;
 
   // Save the current work area, in flipped coordinates.
diff --git a/chrome/browser/ui/cocoa/panels/panel_cocoa_unittest.mm b/chrome/browser/ui/cocoa/panels/panel_cocoa_unittest.mm
index 1e3f17f..d77186a 100644
--- a/chrome/browser/ui/cocoa/panels/panel_cocoa_unittest.mm
+++ b/chrome/browser/ui/cocoa/panels/panel_cocoa_unittest.mm
@@ -59,7 +59,7 @@ class PanelCocoaTest : public CocoaProfileTest {
     EXPECT_TRUE(panel->native_panel());  // Native panel is created right away.
     PanelCocoa* native_window =
         static_cast<PanelCocoa*>(panel->native_panel());
-    EXPECT_EQ(panel, native_window->panel_);  // Back pointer initialized.
+    EXPECT_EQ(panel, native_window->panel_.get());  // Back pointer initialized.
 
     PanelAnimatedBoundsObserver bounds_observer(panel);
 
diff --git a/chrome/browser/ui/views/frame/browser_view.cc b/chrome/browser/ui/views/frame/browser_view.cc
index 91265cb..4b5e6fe 100644
--- a/chrome/browser/ui/views/frame/browser_view.cc
+++ b/chrome/browser/ui/views/frame/browser_view.cc
@@ -2602,7 +2602,7 @@ void BrowserView::ActivateAppModalDialog() const {
 
   Browser* modal_browser =
       chrome::FindBrowserWithWebContents(active_dialog->web_contents());
-  if (modal_browser && (browser_ != modal_browser)) {
+  if (modal_browser && (browser_.get() != modal_browser)) {
     modal_browser->window()->FlashFrame(true);
     modal_browser->window()->Activate();
   }
diff --git a/components/browser_sync/browser/profile_sync_service.cc b/components/browser_sync/browser/profile_sync_service.cc
index 6777f3e..dd6636b 100644
--- a/components/browser_sync/browser/profile_sync_service.cc
+++ b/components/browser_sync/browser/profile_sync_service.cc
@@ -689,7 +689,7 @@ void ProfileSyncService::OnGetTokenSuccess(
     const OAuth2TokenService::Request* request,
     const std::string& access_token,
     const base::Time& expiration_time) {
-  DCHECK_EQ(access_token_request_, request);
+  DCHECK_EQ(access_token_request_.get(), request);
   access_token_request_.reset();
   access_token_ = access_token;
   token_receive_time_ = base::Time::Now();
@@ -711,7 +711,7 @@ void ProfileSyncService::OnGetTokenSuccess(
 void ProfileSyncService::OnGetTokenFailure(
     const OAuth2TokenService::Request* request,
     const GoogleServiceAuthError& error) {
-  DCHECK_EQ(access_token_request_, request);
+  DCHECK_EQ(access_token_request_.get(), request);
   DCHECK_NE(error.state(), GoogleServiceAuthError::NONE);
   access_token_request_.reset();
   last_get_token_error_ = error;
diff --git a/components/cronet/android/cronet_url_request_adapter.cc b/components/cronet/android/cronet_url_request_adapter.cc
index 46e7893..9f9c524 100644
--- a/components/cronet/android/cronet_url_request_adapter.cc
+++ b/components/cronet/android/cronet_url_request_adapter.cc
@@ -380,7 +380,7 @@ void CronetURLRequestAdapter::DestroyOnNetworkThread(bool send_on_canceled) {
 
 bool CronetURLRequestAdapter::MaybeReportError(net::URLRequest* request) const {
   DCHECK_NE(net::URLRequestStatus::IO_PENDING, url_request_->status().status());
-  DCHECK_EQ(request, url_request_);
+  DCHECK_EQ(request, url_request_.get());
   if (url_request_->status().is_success())
     return false;
   int net_error = url_request_->status().error();
diff --git a/components/invalidation/impl/gcm_invalidation_bridge.cc b/components/invalidation/impl/gcm_invalidation_bridge.cc
index dbc44fe..e05398f 100644
--- a/components/invalidation/impl/gcm_invalidation_bridge.cc
+++ b/components/invalidation/impl/gcm_invalidation_bridge.cc
@@ -214,7 +214,7 @@ void GCMInvalidationBridge::OnGetTokenSuccess(
     const std::string& access_token,
     const base::Time& expiration_time) {
   DCHECK(CalledOnValidThread());
-  DCHECK_EQ(access_token_request_, request);
+  DCHECK_EQ(access_token_request_.get(), request);
   core_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&GCMInvalidationBridge::Core::RequestTokenFinished,
@@ -230,7 +230,7 @@ void GCMInvalidationBridge::OnGetTokenFailure(
     const OAuth2TokenService::Request* request,
     const GoogleServiceAuthError& error) {
   DCHECK(CalledOnValidThread());
-  DCHECK_EQ(access_token_request_, request);
+  DCHECK_EQ(access_token_request_.get(), request);
   core_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&GCMInvalidationBridge::Core::RequestTokenFinished,
diff --git a/components/invalidation/impl/gcm_network_channel.cc b/components/invalidation/impl/gcm_network_channel.cc
index d55796e..b96d929 100644
--- a/components/invalidation/impl/gcm_network_channel.cc
+++ b/components/invalidation/impl/gcm_network_channel.cc
@@ -231,7 +231,7 @@ void GCMNetworkChannel::OnGetTokenComplete(
 
 void GCMNetworkChannel::OnURLFetchComplete(const net::URLFetcher* source) {
   DCHECK(CalledOnValidThread());
-  DCHECK_EQ(fetcher_, source);
+  DCHECK_EQ(fetcher_.get(), source);
   // Free fetcher at the end of function.
   scoped_ptr<net::URLFetcher> fetcher = fetcher_.Pass();
 
diff --git a/components/invalidation/impl/ticl_invalidation_service.cc b/components/invalidation/impl/ticl_invalidation_service.cc
index 43a9c9d..6f75182 100644
--- a/components/invalidation/impl/ticl_invalidation_service.cc
+++ b/components/invalidation/impl/ticl_invalidation_service.cc
@@ -205,7 +205,7 @@ void TiclInvalidationService::OnGetTokenSuccess(
     const OAuth2TokenService::Request* request,
     const std::string& access_token,
     const base::Time& expiration_time) {
-  DCHECK_EQ(access_token_request_, request);
+  DCHECK_EQ(access_token_request_.get(), request);
   access_token_request_.reset();
   // Reset backoff time after successful response.
   request_access_token_backoff_.Reset();
@@ -220,7 +220,7 @@ void TiclInvalidationService::OnGetTokenSuccess(
 void TiclInvalidationService::OnGetTokenFailure(
     const OAuth2TokenService::Request* request,
     const GoogleServiceAuthError& error) {
-  DCHECK_EQ(access_token_request_, request);
+  DCHECK_EQ(access_token_request_.get(), request);
   DCHECK_NE(error.state(), GoogleServiceAuthError::NONE);
   access_token_request_.reset();
   switch (error.state()) {
diff --git a/components/search_engines/util.cc b/components/search_engines/util.cc
index 2e16a9c..01c9597 100644
--- a/components/search_engines/util.cc
+++ b/components/search_engines/util.cc
@@ -202,8 +202,8 @@ void MergeEnginesFromPrepopulateData(
   for (std::vector<TemplateURL*>::iterator i = actions.removed_engines.begin();
        i < actions.removed_engines.end(); ++i) {
     scoped_ptr<TemplateURL> template_url(*i);
-    TemplateURLService::TemplateURLVector::iterator j =
-        std::find(template_urls->begin(), template_urls->end(), template_url);
+    TemplateURLService::TemplateURLVector::iterator j = std::find(
+        template_urls->begin(), template_urls->end(), template_url.get());
     DCHECK(j != template_urls->end());
     DCHECK(!default_search_provider ||
            (*j)->prepopulate_id() != default_search_provider->prepopulate_id());
diff --git a/components/sync_driver/profile_sync_auth_provider.cc b/components/sync_driver/profile_sync_auth_provider.cc
index 7a21674..4f269ed 100644
--- a/components/sync_driver/profile_sync_auth_provider.cc
+++ b/components/sync_driver/profile_sync_auth_provider.cc
@@ -101,14 +101,14 @@ void ProfileSyncAuthProvider::OnGetTokenSuccess(
     const OAuth2TokenService::Request* request,
     const std::string& access_token,
     const base::Time& expiration_time) {
-  DCHECK_EQ(access_token_request_, request);
+  DCHECK_EQ(access_token_request_.get(), request);
   RespondToTokenRequest(GoogleServiceAuthError::AuthErrorNone(), access_token);
 }
 
 void ProfileSyncAuthProvider::OnGetTokenFailure(
     const OAuth2TokenService::Request* request,
     const GoogleServiceAuthError& error) {
-  DCHECK_EQ(access_token_request_, request);
+  DCHECK_EQ(access_token_request_.get(), request);
   RespondToTokenRequest(error, std::string());
 }
 
diff --git a/content/browser/appcache/appcache_update_job.cc b/content/browser/appcache/appcache_update_job.cc
index ff06550..e0c2372 100644
--- a/content/browser/appcache/appcache_update_job.cc
+++ b/content/browser/appcache/appcache_update_job.cc
@@ -174,7 +174,7 @@ void AppCacheUpdateJob::URLFetcher::OnReceivedRedirect(
     net::URLRequest* request,
     const net::RedirectInfo& redirect_info,
     bool* defer_redirect) {
-  DCHECK(request_ == request);
+  DCHECK_EQ(request_.get(), request);
   // Redirect is not allowed by the update process.
   job_->MadeProgress();
   redirect_response_code_ = request->GetResponseCode();
@@ -185,7 +185,7 @@ void AppCacheUpdateJob::URLFetcher::OnReceivedRedirect(
 
 void AppCacheUpdateJob::URLFetcher::OnResponseStarted(
     net::URLRequest *request) {
-  DCHECK(request == request_);
+  DCHECK_EQ(request_.get(), request);
   int response_code = -1;
   if (request->status().is_success()) {
     response_code = request->GetResponseCode();
@@ -244,7 +244,7 @@ void AppCacheUpdateJob::URLFetcher::OnResponseStarted(
 
 void AppCacheUpdateJob::URLFetcher::OnReadCompleted(
     net::URLRequest* request, int bytes_read) {
-  DCHECK(request_ == request);
+  DCHECK_EQ(request_.get(), request);
   bool data_consumed = true;
   if (request->status().is_success() && bytes_read > 0) {
     job_->MadeProgress();
@@ -270,7 +270,8 @@ void AppCacheUpdateJob::URLFetcher::OnReadCompleted(
 
 void AppCacheUpdateJob::URLFetcher::AddConditionalHeaders(
     const net::HttpResponseHeaders* headers) {
-  DCHECK(request_.get() && headers);
+  DCHECK(request_);
+  DCHECK(headers);
   net::HttpRequestHeaders extra_headers;
 
   // Add If-Modified-Since header if response info has Last-Modified header.
diff --git a/content/browser/frame_host/render_frame_host_manager.cc b/content/browser/frame_host/render_frame_host_manager.cc
index 1f6101d..4cf2867 100644
--- a/content/browser/frame_host/render_frame_host_manager.cc
+++ b/content/browser/frame_host/render_frame_host_manager.cc
@@ -399,7 +399,7 @@ RenderFrameHostImpl* RenderFrameHostManager::Navigate(
   // If the current render_frame_host_ isn't live, we should create it so
   // that we don't show a sad tab while the dest_render_frame_host fetches
   // its first page.  (Bug 1145340)
-  if (dest_render_frame_host != render_frame_host_ &&
+  if (dest_render_frame_host != render_frame_host_.get() &&
       !render_frame_host_->IsRenderFrameLive()) {
     // Note: we don't call InitRenderView here because we are navigating away
     // soon anyway, and we don't have the NavigationEntry for this host.
@@ -429,7 +429,7 @@ RenderFrameHostImpl* RenderFrameHostManager::Navigate(
     // Now that we've created a new renderer, be sure to hide it if it isn't
     // our primary one.  Otherwise, we might crash if we try to call Show()
     // on it later.
-    if (dest_render_frame_host != render_frame_host_) {
+    if (dest_render_frame_host != render_frame_host_.get()) {
       if (dest_render_frame_host->GetView())
         dest_render_frame_host->GetView()->Hide();
     } else {
@@ -611,8 +611,8 @@ void RenderFrameHostManager::OnCrossSiteResponse(
   // TODO(creis): We need to handle the case that the pending RFH has changed
   // in the mean time, while this was being posted from the IO thread.  We
   // should probably cancel the request in that case.
-  DCHECK(pending_render_frame_host == pending_render_frame_host_ ||
-         pending_render_frame_host == render_frame_host_);
+  DCHECK(pending_render_frame_host == pending_render_frame_host_.get() ||
+         pending_render_frame_host == render_frame_host_.get());
 
   // Store the transferring request so that we can release it if the transfer
   // navigation matches.
@@ -679,7 +679,7 @@ void RenderFrameHostManager::CommitPendingIfNecessary(
     DCHECK(!should_reuse_web_ui_ || web_ui_);
 
     // We should only hear this from our current renderer.
-    DCHECK_EQ(render_frame_host_, render_frame_host);
+    DCHECK_EQ(render_frame_host_.get(), render_frame_host);
 
     // Even when there is no pending RVH, there may be a pending Web UI.
     if (pending_web_ui() || speculative_web_ui_)
@@ -687,11 +687,11 @@ void RenderFrameHostManager::CommitPendingIfNecessary(
     return;
   }
 
-  if (render_frame_host == pending_render_frame_host_ ||
-      render_frame_host == speculative_render_frame_host_) {
+  if (render_frame_host == pending_render_frame_host_.get() ||
+      render_frame_host == speculative_render_frame_host_.get()) {
     // The pending cross-process navigation completed, so show the renderer.
     CommitPending();
-  } else if (render_frame_host == render_frame_host_) {
+  } else if (render_frame_host == render_frame_host_.get()) {
     if (base::CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kEnableBrowserSideNavigation)) {
       CleanUpNavigation();
@@ -1085,7 +1085,7 @@ RenderFrameHostImpl* RenderFrameHostManager::GetFrameHostForNavigation(
       return nullptr;
     }
 
-    if (navigation_rfh == render_frame_host_) {
+    if (navigation_rfh == render_frame_host_.get()) {
       // TODO(nasko): This is a very ugly hack. The Chrome extensions process
       // manager still uses NotificationService and expects to see a
       // RenderViewHost changed notification after WebContents and
diff --git a/content/browser/service_worker/service_worker_write_to_cache_job.cc b/content/browser/service_worker/service_worker_write_to_cache_job.cc
index fdd2867..24bcd0f 100644
--- a/content/browser/service_worker/service_worker_write_to_cache_job.cc
+++ b/content/browser/service_worker/service_worker_write_to_cache_job.cc
@@ -240,7 +240,7 @@ void ServiceWorkerWriteToCacheJob::OnReceivedRedirect(
     net::URLRequest* request,
     const net::RedirectInfo& redirect_info,
     bool* defer_redirect) {
-  DCHECK_EQ(net_request_, request);
+  DCHECK_EQ(net_request_.get(), request);
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerWriteToCacheJob::OnReceivedRedirect");
   // Script resources can't redirect.
@@ -252,7 +252,7 @@ void ServiceWorkerWriteToCacheJob::OnReceivedRedirect(
 void ServiceWorkerWriteToCacheJob::OnAuthRequired(
     net::URLRequest* request,
     net::AuthChallengeInfo* auth_info) {
-  DCHECK_EQ(net_request_, request);
+  DCHECK_EQ(net_request_.get(), request);
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerWriteToCacheJob::OnAuthRequired");
   // TODO(michaeln): Pass this thru to our jobs client.
@@ -264,7 +264,7 @@ void ServiceWorkerWriteToCacheJob::OnAuthRequired(
 void ServiceWorkerWriteToCacheJob::OnCertificateRequested(
     net::URLRequest* request,
     net::SSLCertRequestInfo* cert_request_info) {
-  DCHECK_EQ(net_request_, request);
+  DCHECK_EQ(net_request_.get(), request);
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerWriteToCacheJob::OnCertificateRequested");
   // TODO(michaeln): Pass this thru to our jobs client.
@@ -278,7 +278,7 @@ void ServiceWorkerWriteToCacheJob::OnSSLCertificateError(
     net::URLRequest* request,
     const net::SSLInfo& ssl_info,
     bool fatal) {
-  DCHECK_EQ(net_request_, request);
+  DCHECK_EQ(net_request_.get(), request);
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerWriteToCacheJob::OnSSLCertificateError");
   // TODO(michaeln): Pass this thru to our jobs client,
@@ -291,7 +291,7 @@ void ServiceWorkerWriteToCacheJob::OnSSLCertificateError(
 void ServiceWorkerWriteToCacheJob::OnBeforeNetworkStart(
     net::URLRequest* request,
     bool* defer) {
-  DCHECK_EQ(net_request_, request);
+  DCHECK_EQ(net_request_.get(), request);
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerWriteToCacheJob::OnBeforeNetworkStart");
   NotifyBeforeNetworkStart(defer);
@@ -299,7 +299,7 @@ void ServiceWorkerWriteToCacheJob::OnBeforeNetworkStart(
 
 void ServiceWorkerWriteToCacheJob::OnResponseStarted(
     net::URLRequest* request) {
-  DCHECK_EQ(net_request_, request);
+  DCHECK_EQ(net_request_.get(), request);
   if (!request->status().is_success()) {
     NotifyDoneHelper(request->status(), kFetchScriptError);
     return;
@@ -401,7 +401,7 @@ void ServiceWorkerWriteToCacheJob::OnWriteDataComplete(net::Error error) {
 
 void ServiceWorkerWriteToCacheJob::OnReadCompleted(net::URLRequest* request,
                                                    int bytes_read) {
-  DCHECK_EQ(net_request_, request);
+  DCHECK_EQ(net_request_.get(), request);
   if (bytes_read < 0) {
     DCHECK(!request->status().is_success());
     NotifyDoneHelper(request->status(), kFetchScriptError);
diff --git a/content/browser/web_contents/web_contents_view_aura.cc b/content/browser/web_contents/web_contents_view_aura.cc
index 3d0b9c7..2d49124 100644
--- a/content/browser/web_contents/web_contents_view_aura.cc
+++ b/content/browser/web_contents/web_contents_view_aura.cc
@@ -455,7 +455,7 @@ class WebContentsViewAura::WindowObserver
   }
 
   void OnWillRemoveWindow(aura::Window* window) override {
-    if (window == view_->window_)
+    if (window == view_->window_.get())
       return;
 
     window->RemoveObserver(this);
@@ -463,8 +463,7 @@ class WebContentsViewAura::WindowObserver
   }
 
   void OnWindowVisibilityChanged(aura::Window* window, bool visible) override {
-    if (window == view_->window_ ||
-        window->parent() == host_window_ ||
+    if (window == view_->window_.get() || window->parent() == host_window_ ||
         window->parent() == view_->window_->GetRootWindow()) {
       UpdateConstrainedWindows(NULL);
     }
@@ -473,7 +472,7 @@ class WebContentsViewAura::WindowObserver
 
   void OnWindowParentChanged(aura::Window* window,
                              aura::Window* parent) override {
-    if (window != view_->window_)
+    if (window != view_->window_.get())
       return;
 
     aura::Window* host_window =
@@ -529,7 +528,7 @@ class WebContentsViewAura::WindowObserver
   void OnWindowBoundsChanged(aura::Window* window,
                              const gfx::Rect& old_bounds,
                              const gfx::Rect& new_bounds) override {
-    if (window == host_window_ || window == view_->window_) {
+    if (window == host_window_ || window == view_->window_.get()) {
       SendScreenRects();
       if (old_bounds.origin() != new_bounds.origin()) {
         TouchSelectionControllerClientAura* selection_controller_client =
@@ -552,7 +551,7 @@ class WebContentsViewAura::WindowObserver
   }
 
   void OnWindowAddedToRootWindow(aura::Window* window) override {
-    if (window == view_->window_) {
+    if (window == view_->window_.get()) {
       window->GetHost()->AddObserver(this);
 #if defined(OS_WIN)
       if (!window->GetRootWindow()->HasObserver(this))
@@ -563,7 +562,7 @@ class WebContentsViewAura::WindowObserver
 
   void OnWindowRemovingFromRootWindow(aura::Window* window,
                                       aura::Window* new_root) override {
-    if (window == view_->window_) {
+    if (window == view_->window_.get()) {
       window->GetHost()->RemoveObserver(this);
 #if defined(OS_WIN)
       window->GetRootWindow()->RemoveObserver(this);
@@ -571,7 +570,7 @@ class WebContentsViewAura::WindowObserver
       const aura::Window::Windows& root_children =
           window->GetRootWindow()->children();
       for (size_t i = 0; i < root_children.size(); ++i) {
-        if (root_children[i] != view_->window_ &&
+        if (root_children[i] != view_->window_.get() &&
             root_children[i] != host_window_) {
           root_children[i]->RemoveObserver(this);
         }
diff --git a/content/common/discardable_shared_memory_heap.cc b/content/common/discardable_shared_memory_heap.cc
index 61f05d3..8cf658b 100644
--- a/content/common/discardable_shared_memory_heap.cc
+++ b/content/common/discardable_shared_memory_heap.cc
@@ -64,7 +64,7 @@ bool DiscardableSharedMemoryHeap::ScopedMemorySegment::IsResident() const {
 
 bool DiscardableSharedMemoryHeap::ScopedMemorySegment::ContainsSpan(
     Span* span) const {
-  return shared_memory_ == span->shared_memory();
+  return shared_memory_.get() == span->shared_memory();
 }
 
 base::trace_event::MemoryAllocatorDump*
@@ -73,7 +73,7 @@ DiscardableSharedMemoryHeap::ScopedMemorySegment::CreateMemoryAllocatorDump(
     size_t block_size,
     const char* name,
     base::trace_event::ProcessMemoryDump* pmd) const {
-  DCHECK_EQ(shared_memory_, span->shared_memory());
+  DCHECK_EQ(shared_memory_.get(), span->shared_memory());
   base::trace_event::MemoryAllocatorDump* dump = pmd->CreateAllocatorDump(name);
   dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameSize,
                   base::trace_event::MemoryAllocatorDump::kUnitsBytes,
diff --git a/device/serial/serial_io_handler_win.cc b/device/serial/serial_io_handler_win.cc
index cd10451..56fe93b 100644
--- a/device/serial/serial_io_handler_win.cc
+++ b/device/serial/serial_io_handler_win.cc
@@ -282,7 +282,7 @@ void SerialIoHandlerWin::OnIOCompleted(
     DWORD bytes_transferred,
     DWORD error) {
   DCHECK(CalledOnValidThread());
-  if (context == comm_context_) {
+  if (context == comm_context_.get()) {
     DWORD errors;
     COMSTAT status;
     if (!ClearCommError(file().GetPlatformFile(), &errors, &status) ||
@@ -318,7 +318,7 @@ void SerialIoHandlerWin::OnIOCompleted(
         ReadCompleted(0, serial::RECEIVE_ERROR_SYSTEM_ERROR);
       }
     }
-  } else if (context == read_context_) {
+  } else if (context == read_context_.get()) {
     if (read_canceled()) {
       ReadCompleted(bytes_transferred, read_cancel_reason());
     } else if (error != ERROR_SUCCESS && error != ERROR_OPERATION_ABORTED) {
@@ -329,7 +329,7 @@ void SerialIoHandlerWin::OnIOCompleted(
                         ? serial::RECEIVE_ERROR_NONE
                         : serial::RECEIVE_ERROR_SYSTEM_ERROR);
     }
-  } else if (context == write_context_) {
+  } else if (context == write_context_.get()) {
     DCHECK(pending_write_buffer());
     if (write_canceled()) {
       WriteCompleted(0, write_cancel_reason());
diff --git a/ios/chrome/browser/updatable_config/updatable_config_base.mm b/ios/chrome/browser/updatable_config/updatable_config_base.mm
index 49a793d..027f699 100644
--- a/ios/chrome/browser/updatable_config/updatable_config_base.mm
+++ b/ios/chrome/browser/updatable_config/updatable_config_base.mm
@@ -63,7 +63,7 @@ class ConfigFetcher : public net::URLFetcherDelegate {
   }
 
   void OnURLFetchComplete(const net::URLFetcher* fetcher) override {
-    DCHECK_EQ(fetcher_, fetcher);
+    DCHECK_EQ(fetcher_.get(), fetcher);
     NSData* responseData = nil;
     if (fetcher_->GetResponseCode() == net::HTTP_OK) {
       std::string response;
diff --git a/net/spdy/spdy_write_queue_unittest.cc b/net/spdy/spdy_write_queue_unittest.cc
index 2fdcf5e..0f83b3e 100644
--- a/net/spdy/spdy_write_queue_unittest.cc
+++ b/net/spdy/spdy_write_queue_unittest.cc
@@ -127,17 +127,17 @@ TEST_F(SpdyWriteQueueTest, DequeuesByPriority) {
   ASSERT_TRUE(write_queue.Dequeue(&frame_type, &frame_producer, &stream));
   EXPECT_EQ(RST_STREAM, frame_type);
   EXPECT_EQ("HIGHEST", ProducerToString(frame_producer.Pass()));
-  EXPECT_EQ(stream_highest, stream.get());
+  EXPECT_EQ(stream_highest.get(), stream.get());
 
   ASSERT_TRUE(write_queue.Dequeue(&frame_type, &frame_producer, &stream));
   EXPECT_EQ(SYN_REPLY, frame_type);
   EXPECT_EQ("MEDIUM", ProducerToString(frame_producer.Pass()));
-  EXPECT_EQ(stream_medium, stream.get());
+  EXPECT_EQ(stream_medium.get(), stream.get());
 
   ASSERT_TRUE(write_queue.Dequeue(&frame_type, &frame_producer, &stream));
   EXPECT_EQ(SYN_STREAM, frame_type);
   EXPECT_EQ("LOW", ProducerToString(frame_producer.Pass()));
-  EXPECT_EQ(NULL, stream.get());
+  EXPECT_EQ(nullptr, stream.get());
 
   EXPECT_FALSE(write_queue.Dequeue(&frame_type, &frame_producer, &stream));
 }
@@ -168,17 +168,17 @@ TEST_F(SpdyWriteQueueTest, DequeuesFIFO) {
   ASSERT_TRUE(write_queue.Dequeue(&frame_type, &frame_producer, &stream));
   EXPECT_EQ(SYN_STREAM, frame_type);
   EXPECT_EQ(1, ProducerToInt(frame_producer.Pass()));
-  EXPECT_EQ(stream1, stream.get());
+  EXPECT_EQ(stream1.get(), stream.get());
 
   ASSERT_TRUE(write_queue.Dequeue(&frame_type, &frame_producer, &stream));
   EXPECT_EQ(SYN_REPLY, frame_type);
   EXPECT_EQ(2, ProducerToInt(frame_producer.Pass()));
-  EXPECT_EQ(stream2, stream.get());
+  EXPECT_EQ(stream2.get(), stream.get());
 
   ASSERT_TRUE(write_queue.Dequeue(&frame_type, &frame_producer, &stream));
   EXPECT_EQ(RST_STREAM, frame_type);
   EXPECT_EQ(3, ProducerToInt(frame_producer.Pass()));
-  EXPECT_EQ(stream3, stream.get());
+  EXPECT_EQ(stream3.get(), stream.get());
 
   EXPECT_FALSE(write_queue.Dequeue(&frame_type, &frame_producer, &stream));
 }
@@ -207,7 +207,7 @@ TEST_F(SpdyWriteQueueTest, RemovePendingWritesForStream) {
     ASSERT_TRUE(write_queue.Dequeue(&frame_type, &frame_producer, &stream));
     EXPECT_EQ(SYN_STREAM, frame_type);
     EXPECT_EQ(i, ProducerToInt(frame_producer.Pass()));
-    EXPECT_EQ(stream1, stream.get());
+    EXPECT_EQ(stream1.get(), stream.get());
   }
 
   SpdyFrameType frame_type = DATA;
@@ -251,7 +251,7 @@ TEST_F(SpdyWriteQueueTest, RemovePendingWritesForStreamsAfter) {
         << "Unable to Dequeue i: " << i;
     EXPECT_EQ(SYN_STREAM, frame_type);
     EXPECT_EQ(i, ProducerToInt(frame_producer.Pass()));
-    EXPECT_EQ(stream1, stream.get());
+    EXPECT_EQ(stream1.get(), stream.get());
   }
 
   SpdyFrameType frame_type = DATA;
diff --git a/net/url_request/url_fetcher_core.cc b/net/url_request/url_fetcher_core.cc
index 1ecf9e5..02a723f 100644
--- a/net/url_request/url_fetcher_core.cc
+++ b/net/url_request/url_fetcher_core.cc
@@ -445,7 +445,7 @@ void URLFetcherCore::OnCertificateRequested(
 
 void URLFetcherCore::OnReadCompleted(URLRequest* request,
                                      int bytes_read) {
-  DCHECK(request == request_);
+  DCHECK_EQ(request, request_.get());
   DCHECK(network_task_runner_->BelongsToCurrentThread());
 
   if (!stopped_on_redirect_)
diff --git a/ui/app_list/app_list_item_list_unittest.cc b/ui/app_list/app_list_item_list_unittest.cc
index 92986ff..ad57f1a 100644
--- a/ui/app_list/app_list_item_list_unittest.cc
+++ b/ui/app_list/app_list_item_list_unittest.cc
@@ -178,7 +178,7 @@ TEST_F(AppListItemListTest, RemoveItemAt) {
   EXPECT_TRUE(VerifyItemListOrdinals());
 
   scoped_ptr<AppListItem> item_removed = RemoveItemAt(1);
-  EXPECT_EQ(item_removed, item_1);
+  EXPECT_EQ(item_removed.get(), item_1);
   EXPECT_FALSE(FindItem(item_1->id()));
   EXPECT_EQ(item_list_.item_count(), 2u);
   EXPECT_EQ(observer_.items_removed(), 1u);
@@ -203,7 +203,7 @@ TEST_F(AppListItemListTest, RemoveItem) {
   EXPECT_EQ(index, 1u);
 
   scoped_ptr<AppListItem> item_removed = RemoveItem(item_1->id());
-  EXPECT_EQ(item_removed, item_1);
+  EXPECT_EQ(item_removed.get(), item_1);
   EXPECT_FALSE(FindItem(item_1->id()));
   EXPECT_EQ(item_list_.item_count(), 2u);
   EXPECT_EQ(observer_.items_removed(), 1u);
diff --git a/ui/aura/window.cc b/ui/aura/window.cc
index 6ff6c76..c97941d 100644
--- a/ui/aura/window.cc
+++ b/ui/aura/window.cc
@@ -276,7 +276,7 @@ void Window::SetTransform(const gfx::Transform& transform) {
 }
 
 void Window::SetLayoutManager(LayoutManager* layout_manager) {
-  if (layout_manager == layout_manager_)
+  if (layout_manager == layout_manager_.get())
     return;
   layout_manager_.reset(layout_manager);
   if (!layout_manager)
diff --git a/ui/views/bubble/bubble_delegate_unittest.cc b/ui/views/bubble/bubble_delegate_unittest.cc
index ec5ab14..16f14c5 100644
--- a/ui/views/bubble/bubble_delegate_unittest.cc
+++ b/ui/views/bubble/bubble_delegate_unittest.cc
@@ -91,12 +91,12 @@ TEST_F(BubbleDelegateTest, CloseAnchorWidget) {
   Widget* bubble_widget = BubbleDelegateView::CreateBubble(bubble_delegate);
   EXPECT_EQ(bubble_delegate, bubble_widget->widget_delegate());
   EXPECT_EQ(bubble_widget, bubble_delegate->GetWidget());
-  EXPECT_EQ(anchor_widget, bubble_delegate->anchor_widget());
+  EXPECT_EQ(anchor_widget.get(), bubble_delegate->anchor_widget());
   test::TestWidgetObserver bubble_observer(bubble_widget);
   EXPECT_FALSE(bubble_observer.widget_closed());
 
   bubble_widget->Show();
-  EXPECT_EQ(anchor_widget, bubble_delegate->anchor_widget());
+  EXPECT_EQ(anchor_widget.get(), bubble_delegate->anchor_widget());
   EXPECT_FALSE(bubble_observer.widget_closed());
 
   // TODO(msw): Remove activation hack to prevent bookkeeping errors in:
@@ -126,7 +126,7 @@ TEST_F(BubbleDelegateTest, CloseAnchorViewTest) {
   // Check that the anchor view is correct and set up an anchor view rect.
   // Make sure that this rect will get ignored (as long as the anchor view is
   // attached).
-  EXPECT_EQ(anchor_view, bubble_delegate->GetAnchorView());
+  EXPECT_EQ(anchor_view.get(), bubble_delegate->GetAnchorView());
   const gfx::Rect set_anchor_rect = gfx::Rect(10, 10, 100, 100);
   bubble_delegate->SetAnchorRectForTest(set_anchor_rect);
   const gfx::Rect view_rect = bubble_delegate->GetAnchorRect();
@@ -134,7 +134,7 @@ TEST_F(BubbleDelegateTest, CloseAnchorViewTest) {
 
   // Create the bubble.
   bubble_widget->Show();
-  EXPECT_EQ(anchor_widget, bubble_delegate->anchor_widget());
+  EXPECT_EQ(anchor_widget.get(), bubble_delegate->anchor_widget());
 
   // Remove now the anchor view and make sure that the original found rect
   // is still kept, so that the bubble does not jump when the view gets deleted.
@@ -174,20 +174,20 @@ TEST_F(BubbleDelegateTest, ResetAnchorWidget) {
   Widget* bubble_widget = BubbleDelegateView::CreateBubble(bubble_delegate);
   EXPECT_EQ(bubble_delegate, bubble_widget->widget_delegate());
   EXPECT_EQ(bubble_widget, bubble_delegate->GetWidget());
-  EXPECT_EQ(anchor_widget, bubble_delegate->anchor_widget());
+  EXPECT_EQ(anchor_widget.get(), bubble_delegate->anchor_widget());
   test::TestWidgetObserver bubble_observer(bubble_widget);
   EXPECT_FALSE(bubble_observer.widget_closed());
 
   // Showing and hiding the bubble widget should have no effect on its anchor.
   bubble_widget->Show();
-  EXPECT_EQ(anchor_widget, bubble_delegate->anchor_widget());
+  EXPECT_EQ(anchor_widget.get(), bubble_delegate->anchor_widget());
   bubble_widget->Hide();
-  EXPECT_EQ(anchor_widget, bubble_delegate->anchor_widget());
+  EXPECT_EQ(anchor_widget.get(), bubble_delegate->anchor_widget());
 
   // Ensure that closing the anchor widget clears the bubble's reference to that
   // anchor widget, but the bubble itself does not close.
   anchor_widget->CloseNow();
-  EXPECT_NE(anchor_widget, bubble_delegate->anchor_widget());
+  EXPECT_NE(anchor_widget.get(), bubble_delegate->anchor_widget());
   EXPECT_FALSE(bubble_observer.widget_closed());
 
   // TODO(msw): Remove activation hack to prevent bookkeeping errors in:
diff --git a/ui/views/controls/webview/webview.cc b/ui/views/controls/webview/webview.cc
index 8e6465e..a75e470 100644
--- a/ui/views/controls/webview/webview.cc
+++ b/ui/views/controls/webview/webview.cc
@@ -65,7 +65,7 @@ void WebView::SetWebContents(content::WebContents* replacement) {
   }
   // web_contents() now returns |replacement| from here onwards.
   SetFocusable(!!web_contents());
-  if (wc_owner_ != replacement)
+  if (wc_owner_.get() != replacement)
     wc_owner_.reset();
   if (embed_fullscreen_widget_mode_enabled_) {
     is_embedding_fullscreen_widget_ =
diff --git a/ui/views/touchui/touch_selection_controller_impl.cc b/ui/views/touchui/touch_selection_controller_impl.cc
index d273ee3..3a26e61 100644
--- a/ui/views/touchui/touch_selection_controller_impl.cc
+++ b/ui/views/touchui/touch_selection_controller_impl.cc
@@ -504,7 +504,7 @@ void TouchSelectionControllerImpl::SelectionChanged() {
     if (dragging_handle_ != cursor_handle_.get()) {
       // The non-dragging-handle might have recently become visible.
       EditingHandleView* non_dragging_handle = selection_handle_1_.get();
-      if (dragging_handle_ == selection_handle_1_) {
+      if (dragging_handle_ == selection_handle_1_.get()) {
         non_dragging_handle = selection_handle_2_.get();
         // if handle 1 is being dragged, it is corresponding to the end of
         // selection and the other handle to the start of selection.
@@ -567,8 +567,8 @@ void TouchSelectionControllerImpl::SelectionHandleDragged(
 
   // Find the stationary selection handle.
   ui::SelectionBound anchor_bound =
-      selection_handle_1_ == dragging_handle_ ? selection_bound_2_
-                                              : selection_bound_1_;
+      selection_handle_1_.get() == dragging_handle_ ? selection_bound_2_
+                                                    : selection_bound_1_;
 
   // Find selection end points in client_view's coordinate system.
   gfx::Point p2 = anchor_bound.edge_top_rounded();
diff --git a/ui/views/view_unittest.cc b/ui/views/view_unittest.cc
index 38683cc..75fa552 100644
--- a/ui/views/view_unittest.cc
+++ b/ui/views/view_unittest.cc
@@ -2169,11 +2169,11 @@ TEST_F(ViewTest, MAYBE_NativeViewHierarchyChanged) {
   EXPECT_EQ(NULL, observer_view->toplevel());
 
   child->SetContentsView(observer_view);
-  EXPECT_EQ(toplevel1, observer_view->toplevel());
+  EXPECT_EQ(toplevel1.get(), observer_view->toplevel());
 
   Widget::ReparentNativeView(child->GetNativeView(),
                              toplevel2->GetNativeView());
-  EXPECT_EQ(toplevel2, observer_view->toplevel());
+  EXPECT_EQ(toplevel2.get(), observer_view->toplevel());
 
   observer_view->parent()->RemoveChildView(observer_view);
   EXPECT_EQ(NULL, observer_view->toplevel());
@@ -3921,7 +3921,7 @@ TEST_F(ViewLayerTest, RecreateLayerZOrder) {
   const std::vector<ui::Layer*>& child_layers_post = v->layer()->children();
   ASSERT_EQ(3u, child_layers_post.size());
   EXPECT_EQ(v1->layer(), child_layers_post[0]);
-  EXPECT_EQ(v1_old_layer, child_layers_post[1]);
+  EXPECT_EQ(v1_old_layer.get(), child_layers_post[1]);
   EXPECT_EQ(v2->layer(), child_layers_post[2]);
 }
 
@@ -3952,7 +3952,7 @@ TEST_F(ViewLayerTest, RecreateLayerZOrderWidgetParent) {
   const std::vector<ui::Layer*>& child_layers_post = root_layer->children();
   ASSERT_EQ(3u, child_layers_post.size());
   EXPECT_EQ(v1->layer(), child_layers_post[0]);
-  EXPECT_EQ(v1_old_layer, child_layers_post[1]);
+  EXPECT_EQ(v1_old_layer.get(), child_layers_post[1]);
   EXPECT_EQ(v2->layer(), child_layers_post[2]);
 }