Remove implicit scoped_refptr 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/command_line.h"
 #include "base/file_path.h"
@@ skipping 1611 matching lines @@
   backend_->SetFavicons(page_url1, FAVICON, favicon_bitmap_data,
                         icon_url_sizes);
 
   std::vector<GURL> icon_urls;
   icon_urls.push_back(icon_url);
 
   scoped_refptr<GetFaviconRequest> request(new GetFaviconRequest(
       base::Bind(&HistoryBackendTest::OnFaviconResults,
                  base::Unretained(this))));
   HistoryBackendCancelableRequest cancellable_request;
-  cancellable_request.MockScheduleOfRequest<GetFaviconRequest>(request);
+  cancellable_request.MockScheduleOfRequest<GetFaviconRequest>(request.get());
   backend_->UpdateFaviconMappingsAndFetch(request, page_url2, icon_urls,
       FAVICON, kSmallSize.width(), GetScaleFactors1x2x());
 
   // Check that the same FaviconID is mapped to both page URLs.
   std::vector<IconMapping> icon_mappings;
   EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingsForPageURL(
       page_url1, &icon_mappings));
   EXPECT_EQ(1u, icon_mappings.size());
   FaviconID favicon_id = icon_mappings[0].icon_id;
   EXPECT_NE(0, favicon_id);
@@ skipping 60 matching lines @@
       icon_url, FAVICON, NULL);
   EXPECT_NE(0, icon_id);
   EXPECT_EQ(1, num_broadcasted_notifications());
 
   std::vector<GURL> icon_urls;
   icon_urls.push_back(icon_url);
   scoped_refptr<GetFaviconRequest> request(new GetFaviconRequest(
       base::Bind(&HistoryBackendTest::OnFaviconResults,
                  base::Unretained(this))));
   HistoryBackendCancelableRequest cancellable_request;
-  cancellable_request.MockScheduleOfRequest<GetFaviconRequest>(request);
+  cancellable_request.MockScheduleOfRequest<GetFaviconRequest>(request.get());
   backend_->UpdateFaviconMappingsAndFetch(request, page_url, icon_urls,
       FAVICON, kSmallSize.width(), GetScaleFactors1x2x());
 
   EXPECT_EQ(icon_id, backend_->thumbnail_db_->GetFaviconIDForFaviconURL(
       icon_url, FAVICON, NULL));
 
   // No notification should have been broadcast as no icon mapping, favicon,
   // or favicon bitmap was updated, added or removed.
   EXPECT_EQ(1, num_broadcasted_notifications());
 }
@@ skipping 268 matching lines @@
   std::vector<unsigned char> data;
   data.push_back('c');
   scoped_refptr<base::RefCountedBytes> bitmap_data(
       new base::RefCountedBytes(data));
   backend_->MergeFavicon(page_url, FAVICON, bitmap_data, kSmallSize);
 
   HistoryBackendCancelableRequest cancellable_request;
   scoped_refptr<GetFaviconRequest> request(new GetFaviconRequest(
       base::Bind(&HistoryBackendTest::OnFaviconResults,
                  base::Unretained(this))));
-  cancellable_request.MockScheduleOfRequest<GetFaviconRequest>(request);
+  cancellable_request.MockScheduleOfRequest<GetFaviconRequest>(request.get());
 
   // Request favicon bitmaps for both 1x and 2x to simulate request done by
   // BookmarkModel::GetFavicon().
   backend_->GetFaviconsForURL(request, page_url, FAVICON, kSmallSize.width(),
       GetScaleFactors1x2x());
 
   const std::vector<history::FaviconBitmapResult> favicon_bitmap_results =
       get_favicon_bitmap_results();
   EXPECT_EQ(2u, favicon_bitmap_results.size());
   const FaviconBitmapResult& first_result = favicon_bitmap_results[0];
@@ skipping 31 matching lines @@
                         icon_url_sizes);
 
   std::vector<GURL> icon_urls;
   icon_urls.push_back(icon_urla);
   icon_urls.push_back(icon_urlb);
   icon_urls.push_back(icon_urlc);
   scoped_refptr<GetFaviconRequest> request(new GetFaviconRequest(
       base::Bind(&HistoryBackendTest::OnFaviconResults,
                  base::Unretained(this))));
   HistoryBackendCancelableRequest cancellable_request;
-  cancellable_request.MockScheduleOfRequest<GetFaviconRequest>(request);
+  cancellable_request.MockScheduleOfRequest<GetFaviconRequest>(request.get());
   backend_->UpdateFaviconMappingsAndFetch(request, page_url3, icon_urls,
       TOUCH_ICON | TOUCH_PRECOMPOSED_ICON, kSmallSize.width(),
       GetScaleFactors1x2x());
 
   // |page_url1| and |page_url2| should still be mapped to the same icon URLs.
   std::vector<IconMapping> icon_mappings;
   EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingsForPageURL(page_url1,
       &icon_mappings));
   EXPECT_EQ(1u, icon_mappings.size());
   EXPECT_EQ(icon_urla, icon_mappings[0].icon_url);
@@ skipping 206 matching lines @@
 // to the UI when there is no valid thumbnail database.
 TEST_F(HistoryBackendTest, GetFaviconsNoDB) {
   // Make the thumbnail database invalid.
   backend_->thumbnail_db_.reset();
 
   HistoryBackendCancelableRequest cancellable_request;
 
   scoped_refptr<GetFaviconRequest> request1(new GetFaviconRequest(
       base::Bind(&HistoryBackendTest::OnFaviconResults,
                  base::Unretained(this))));
-  cancellable_request.MockScheduleOfRequest<GetFaviconRequest>(request1);
+  cancellable_request.MockScheduleOfRequest<GetFaviconRequest>(request1.get());
   EXPECT_TRUE(cancellable_request.HasPendingRequests());
   backend_->UpdateFaviconMappingsAndFetch(request1, GURL(), std::vector<GURL>(),
       FAVICON, kSmallSize.width(), GetScaleFactors1x2x());
   EXPECT_FALSE(cancellable_request.HasPendingRequests());
 
   scoped_refptr<GetFaviconRequest> request2(new GetFaviconRequest(
       base::Bind(&HistoryBackendTest::OnFaviconResults,
                  base::Unretained(this))));
-  cancellable_request.MockScheduleOfRequest<GetFaviconRequest>(request2);
+  cancellable_request.MockScheduleOfRequest<GetFaviconRequest>(request2.get());
   EXPECT_TRUE(cancellable_request.HasPendingRequests());
   backend_->GetFaviconsForURL(request2, GURL(), FAVICON, kSmallSize.width(),
                               GetScaleFactors1x2x());
   EXPECT_FALSE(cancellable_request.HasPendingRequests());
 }
 
 TEST_F(HistoryBackendTest, CloneFaviconIsRestrictedToSameDomain) {
   const GURL url("http://www.google.com/");
   const GURL same_domain_url("http://www.google.com/subdir/index.html");
   const GURL foreign_domain_url("http://www.not-google.com/");
@@ skipping 115 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 132 matching lines @@
 
     backend_->DeleteURL(url);
     backend_->AddPageNoVisitForBookmark(url, string16());
     backend_->GetURL(url, &row);
     EXPECT_EQ(url, row.url());
     EXPECT_EQ(UTF8ToUTF16(url.spec()), row.title());
     EXPECT_EQ(0, row.visit_count());
 }
 
 }  // namespace history