Update chrome/ to use scoped_refptr<T>::get() rather than implicit "operator T*"

chrome/browser/history/history_backend_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <algorithm>
 #include <set>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 369 matching lines @@
                                   &bookmark_model_);
     backend_->Init(std::string(), false);
   }
 
   bool loaded_;
 
  private:
   friend class HistoryBackendTestDelegate;
 
   virtual void TearDown() {
-    if (backend_)
+    if (backend_.get())
       backend_->Closing();
     backend_ = NULL;
     mem_backend_.reset();
     file_util::Delete(test_dir_, true);
   }
 
   void SetInMemoryBackend(int backend_id, InMemoryHistoryBackend* backend) {
     mem_backend_.reset(backend);
   }
 
@@ skipping 1939 matching lines @@
                                         kTypedTransition,
                                         tested_time - half_an_hour);
   backend_->Commit();
 
   scoped_refptr<QueryFilteredURLsRequest> request1 =
       new history::QueryFilteredURLsRequest(
           base::Bind(&HistoryBackendTest::OnQueryFiltered,
                      base::Unretained(static_cast<HistoryBackendTest*>(this))));
   HistoryBackendCancelableRequest cancellable_request;
   cancellable_request.MockScheduleOfRequest<QueryFilteredURLsRequest>(
-      request1);
+      request1.get());
 
   VisitFilter filter;
   // Time limit is |tested_time| +/- 45 min.
   base::TimeDelta three_quarters_of_an_hour = base::TimeDelta::FromMinutes(45);
   filter.SetFilterTime(tested_time);
   filter.SetFilterWidth(three_quarters_of_an_hour);
   backend_->QueryFilteredURLs(request1, 100, filter, false);
 
   ASSERT_EQ(4U, get_filtered_list().size());
   EXPECT_EQ(std::string(google), get_filtered_list()[0].url.spec());
   EXPECT_EQ(std::string(yahoo_sports_soccer),
             get_filtered_list()[1].url.spec());
   EXPECT_EQ(std::string(yahoo), get_filtered_list()[2].url.spec());
   EXPECT_EQ(std::string(yahoo_sports),
             get_filtered_list()[3].url.spec());
 
   // Time limit is between |tested_time| and |tested_time| + 2 hours.
   scoped_refptr<QueryFilteredURLsRequest> request2 =
       new history::QueryFilteredURLsRequest(
           base::Bind(&HistoryBackendTest::OnQueryFiltered,
                      base::Unretained(static_cast<HistoryBackendTest*>(this))));
   cancellable_request.MockScheduleOfRequest<QueryFilteredURLsRequest>(
-      request2);
+      request2.get());
   filter.SetFilterTime(tested_time + one_hour);
   filter.SetFilterWidth(one_hour);
   backend_->QueryFilteredURLs(request2, 100, filter, false);
 
   ASSERT_EQ(3U, get_filtered_list().size());
   EXPECT_EQ(std::string(google), get_filtered_list()[0].url.spec());
   EXPECT_EQ(std::string(yahoo), get_filtered_list()[1].url.spec());
   EXPECT_EQ(std::string(yahoo_sports), get_filtered_list()[2].url.spec());
 
   // Time limit is between |tested_time| - 2 hours and |tested_time|.
   scoped_refptr<QueryFilteredURLsRequest> request3 =
       new history::QueryFilteredURLsRequest(
           base::Bind(&HistoryBackendTest::OnQueryFiltered,
                      base::Unretained(static_cast<HistoryBackendTest*>(this))));
   cancellable_request.MockScheduleOfRequest<QueryFilteredURLsRequest>(
-      request3);
+      request3.get());
   filter.SetFilterTime(tested_time - one_hour);
   filter.SetFilterWidth(one_hour);
   backend_->QueryFilteredURLs(request3, 100, filter, false);
 
   ASSERT_EQ(3U, get_filtered_list().size());
   EXPECT_EQ(std::string(google), get_filtered_list()[0].url.spec());
   EXPECT_EQ(std::string(yahoo_sports_soccer),
             get_filtered_list()[1].url.spec());
   EXPECT_EQ(std::string(yahoo_sports), get_filtered_list()[2].url.spec());
 
   filter.ClearFilters();
   base::Time::Exploded exploded_time;
   tested_time.LocalExplode(&exploded_time);
 
   // Today.
   scoped_refptr<QueryFilteredURLsRequest> request4 =
       new history::QueryFilteredURLsRequest(
           base::Bind(&HistoryBackendTest::OnQueryFiltered,
                      base::Unretained(static_cast<HistoryBackendTest*>(this))));
   cancellable_request.MockScheduleOfRequest<QueryFilteredURLsRequest>(
-      request4);
+      request4.get());
   filter.SetFilterTime(tested_time);
   filter.SetDayOfTheWeekFilter(static_cast<int>(exploded_time.day_of_week));
   backend_->QueryFilteredURLs(request4, 100, filter, false);
 
   ASSERT_EQ(2U, get_filtered_list().size());
   EXPECT_EQ(std::string(google), get_filtered_list()[0].url.spec());
   EXPECT_EQ(std::string(yahoo_sports_soccer),
             get_filtered_list()[1].url.spec());
 
   // Today + time limit - only yahoo_sports_soccer should fit.
   scoped_refptr<QueryFilteredURLsRequest> request5 =
       new history::QueryFilteredURLsRequest(
           base::Bind(&HistoryBackendTest::OnQueryFiltered,
                      base::Unretained(static_cast<HistoryBackendTest*>(this))));
   cancellable_request.MockScheduleOfRequest<QueryFilteredURLsRequest>(
-      request5);
+      request5.get());
   filter.SetFilterTime(tested_time - base::TimeDelta::FromMinutes(40));
   filter.SetFilterWidth(base::TimeDelta::FromMinutes(20));
   backend_->QueryFilteredURLs(request5, 100, filter, false);
 
   ASSERT_EQ(1U, get_filtered_list().size());
   EXPECT_EQ(std::string(yahoo_sports_soccer),
             get_filtered_list()[0].url.spec());
 
   // Make sure we get debug data if we request it.
   scoped_refptr<QueryFilteredURLsRequest> request6 =
       new history::QueryFilteredURLsRequest(
           base::Bind(&HistoryBackendTest::OnQueryFiltered,
                      base::Unretained(static_cast<HistoryBackendTest*>(this))));
   cancellable_request.MockScheduleOfRequest<QueryFilteredURLsRequest>(
-      request6);
+      request6.get());
   filter.SetFilterTime(tested_time);
   filter.SetFilterWidth(one_hour * 2);
   backend_->QueryFilteredURLs(request6, 100, filter, true);
 
   // If the SegmentID is used by QueryFilteredURLs when generating the debug
   // data instead of the URLID, the |total_visits| for the |yahoo_sports_soccer|
   // entry will be zero instead of 1.
   ASSERT_GE(get_filtered_list().size(), 2U);
   EXPECT_EQ(std::string(google), get_filtered_list()[0].url.spec());
   EXPECT_EQ(std::string(yahoo_sports_soccer),
@@ skipping 357 matching lines @@
   service->AddPage(
       url, base::Time::Now(), NULL, 1, GURL(), RedirectList(),
       content::PAGE_TRANSITION_TYPED, SOURCE_BROWSED, false);
 
   // This won't actually delete the URL, rather it'll empty out the visits.
   // This triggers blocking on the BookmarkModel.
   service->DeleteURL(url);
 }
 
 }  // namespace history