Call scoped_refptr<T>::get() rather than relying on implicit "operator T*"

net/url_request/url_fetcher_impl_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 "net/url_request/url_fetcher_impl.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 146 matching lines @@
  protected:
   GURL test_url_;
   scoped_ptr<SpawnedTestServer> test_server_;
   MockHostResolver resolver_;
   scoped_ptr<URLFetcher> completed_fetcher_;
 };
 
 void URLFetcherTest::CreateFetcher(const GURL& url) {
   fetcher_ = new URLFetcherImpl(url, URLFetcher::GET, this);
   fetcher_->SetRequestContext(new ThrottlingTestURLRequestContextGetter(
-      io_message_loop_proxy(), request_context()));
+      io_message_loop_proxy().get(), request_context()));
   fetcher_->Start();
 }
 
 void URLFetcherTest::OnURLFetchComplete(const URLFetcher* source) {
   EXPECT_TRUE(source->GetStatus().is_success());
   EXPECT_EQ(200, source->GetResponseCode());  // HTTP OK
 
   std::string data;
   EXPECT_TRUE(source->GetResponseAsString(&data));
   EXPECT_FALSE(data.empty());
@@ skipping 32 matching lines @@
   // trigger an async resolve.
   test_url_ = GURL(
       base::StringPrintf("http://example.com:%d/defaultresponse",
       test_server_->host_port_pair().port()));
   ASSERT_TRUE(test_url_.is_valid());
 }
 
 void URLFetcherMockDnsTest::CreateFetcher(const GURL& url) {
   fetcher_ = new URLFetcherImpl(url, URLFetcher::GET, this);
   fetcher_->SetRequestContext(new ThrottlingTestURLRequestContextGetter(
-      io_message_loop_proxy(), request_context()));
+      io_message_loop_proxy().get(), request_context()));
 }
 
 void URLFetcherMockDnsTest::OnURLFetchComplete(const URLFetcher* source) {
   io_message_loop_proxy()->PostTask(FROM_HERE,
                                     base::MessageLoop::QuitClosure());
   ASSERT_EQ(fetcher_, source);
   EXPECT_EQ(test_url_, source->GetOriginalURL());
   completed_fetcher_.reset(fetcher_);
 }
 
@@ skipping 284 matching lines @@
   // disowning prevents the file from being deleted.
   bool take_ownership_of_file_;
 
   // Expected file error code for the test.  OK when expecting success.
   int expected_file_error_;
 };
 
 void URLFetcherPostTest::CreateFetcher(const GURL& url) {
   fetcher_ = new URLFetcherImpl(url, URLFetcher::POST, this);
   fetcher_->SetRequestContext(new ThrottlingTestURLRequestContextGetter(
-      io_message_loop_proxy(), request_context()));
-  fetcher_->SetUploadData("application/x-www-form-urlencoded",
-                          "bobsyeruncle");
+      io_message_loop_proxy().get(), request_context()));
+  fetcher_->SetUploadData("application/x-www-form-urlencoded", "bobsyeruncle");
   fetcher_->Start();
 }
 
 void URLFetcherPostTest::OnURLFetchComplete(const URLFetcher* source) {
   std::string data;
   EXPECT_TRUE(source->GetResponseAsString(&data));
   EXPECT_EQ(std::string("bobsyeruncle"), data);
   URLFetcherTest::OnURLFetchComplete(source);
 }
 
 URLFetcherPostFileTest::URLFetcherPostFileTest()
     : range_offset_(0),
       range_length_(kuint64max) {
   PathService::Get(base::DIR_SOURCE_ROOT, &path_);
   path_ = path_.Append(FILE_PATH_LITERAL("net"));
   path_ = path_.Append(FILE_PATH_LITERAL("data"));
   path_ = path_.Append(FILE_PATH_LITERAL("url_request_unittest"));
   path_ = path_.Append(FILE_PATH_LITERAL("BullRunSpeech.txt"));
 }
 
 void URLFetcherPostFileTest::CreateFetcher(const GURL& url) {
   fetcher_ = new URLFetcherImpl(url, URLFetcher::POST, this);
   fetcher_->SetRequestContext(new ThrottlingTestURLRequestContextGetter(
-      io_message_loop_proxy(), request_context()));
+      io_message_loop_proxy().get(), request_context()));
   fetcher_->SetUploadFilePath("application/x-www-form-urlencoded",
                               path_,
                               range_offset_,
                               range_length_,
                               base::MessageLoopProxy::current());
   fetcher_->Start();
 }
 
 void URLFetcherPostFileTest::OnURLFetchComplete(const URLFetcher* source) {
   std::string expected;
@@ skipping 25 matching lines @@
   EXPECT_TRUE(data.empty());
 
   CleanupAfterFetchComplete();
   // Do not call the super class method URLFetcherTest::OnURLFetchComplete,
   // since it expects a non-empty response.
 }
 
 void URLFetcherDownloadProgressTest::CreateFetcher(const GURL& url) {
   fetcher_ = new URLFetcherImpl(url, URLFetcher::GET, this);
   fetcher_->SetRequestContext(new ThrottlingTestURLRequestContextGetter(
-      io_message_loop_proxy(), request_context()));
+      io_message_loop_proxy().get(), request_context()));
   fetcher_->Start();
 }
 
 void URLFetcherDownloadProgressTest::OnURLFetchDownloadProgress(
     const URLFetcher* source, int64 progress, int64 total) {
   // Increasing between 0 and total.
   EXPECT_LE(0, progress);
   EXPECT_GE(total, progress);
   EXPECT_LE(previous_progress_, progress);
   EXPECT_EQ(expected_total_, total);
   previous_progress_ = progress;
 }
 
 void URLFetcherDownloadProgressCancelTest::CreateFetcher(const GURL& url) {
   fetcher_ = new URLFetcherImpl(url, URLFetcher::GET, this);
   fetcher_->SetRequestContext(new ThrottlingTestURLRequestContextGetter(
-      io_message_loop_proxy(), request_context()));
+      io_message_loop_proxy().get(), request_context()));
   cancelled_ = false;
   fetcher_->Start();
 }
 
 void URLFetcherDownloadProgressCancelTest::OnURLFetchDownloadProgress(
     const URLFetcher* source, int64 current, int64 total) {
   EXPECT_FALSE(cancelled_);
   if (!cancelled_) {
     cancelled_ = true;
     CleanupAfterFetchComplete();
   }
 }
 
 void URLFetcherDownloadProgressCancelTest::OnURLFetchComplete(
     const URLFetcher* source) {
   // Should have been cancelled.
   ADD_FAILURE();
   CleanupAfterFetchComplete();
 }
 
 void URLFetcherUploadProgressTest::CreateFetcher(const GURL& url) {
   fetcher_ = new URLFetcherImpl(url, URLFetcher::POST, this);
   fetcher_->SetRequestContext(new ThrottlingTestURLRequestContextGetter(
-      io_message_loop_proxy(), request_context()));
+      io_message_loop_proxy().get(), request_context()));
   previous_progress_ = 0;
   // Large enough data to require more than one read from UploadDataStream.
   chunk_.assign(1<<16, 'a');
   // Use chunked upload to wait for a timer event of progress notification.
   fetcher_->SetChunkedUpload("application/x-www-form-urlencoded");
   fetcher_->Start();
   number_of_chunks_added_ = 1;
   fetcher_->AppendChunkToUpload(chunk_, false);
 }
 
@@ skipping 36 matching lines @@
 URLFetcherStopOnRedirectTest::URLFetcherStopOnRedirectTest()
     : callback_called_(false) {
 }
 
 URLFetcherStopOnRedirectTest::~URLFetcherStopOnRedirectTest() {
 }
 
 void URLFetcherStopOnRedirectTest::CreateFetcher(const GURL& url) {
   fetcher_ = new URLFetcherImpl(url, URLFetcher::GET, this);
   fetcher_->SetRequestContext(new ThrottlingTestURLRequestContextGetter(
-      io_message_loop_proxy(), request_context()));
+      io_message_loop_proxy().get(), request_context()));
   fetcher_->SetStopOnRedirect(true);
   fetcher_->Start();
 }
 
 void URLFetcherStopOnRedirectTest::OnURLFetchComplete(
     const URLFetcher* source) {
   callback_called_ = true;
   EXPECT_EQ(GURL(kRedirectTarget), source->GetURL());
   EXPECT_EQ(URLRequestStatus::CANCELED, source->GetStatus().status());
   EXPECT_EQ(ERR_ABORTED, source->GetStatus().error());
   EXPECT_EQ(301, source->GetResponseCode());
   CleanupAfterFetchComplete();
 }
 
 void URLFetcherProtectTest::CreateFetcher(const GURL& url) {
   fetcher_ = new URLFetcherImpl(url, URLFetcher::GET, this);
   fetcher_->SetRequestContext(new ThrottlingTestURLRequestContextGetter(
-      io_message_loop_proxy(), request_context()));
+      io_message_loop_proxy().get(), request_context()));
   start_time_ = Time::Now();
   fetcher_->SetMaxRetriesOn5xx(11);
   fetcher_->Start();
 }
 
 void URLFetcherProtectTest::OnURLFetchComplete(const URLFetcher* source) {
   const TimeDelta one_second = TimeDelta::FromMilliseconds(1000);
   if (source->GetResponseCode() >= 500) {
     // Now running ServerUnavailable test.
     // It takes more than 1 second to finish all 11 requests.
     EXPECT_TRUE(Time::Now() - start_time_ >= one_second);
     EXPECT_TRUE(source->GetStatus().is_success());
     std::string data;
     EXPECT_TRUE(source->GetResponseAsString(&data));
     EXPECT_FALSE(data.empty());
     CleanupAfterFetchComplete();
   } else {
     // Now running Overload test.
     static int count = 0;
     count++;
     if (count < 20) {
-      fetcher_->SetRequestContext(
-          new ThrottlingTestURLRequestContextGetter(
-              io_message_loop_proxy(), request_context()));
+      fetcher_->SetRequestContext(new ThrottlingTestURLRequestContextGetter(
+          io_message_loop_proxy().get(), request_context()));
       fetcher_->Start();
     } else {
       // We have already sent 20 requests continuously. And we expect that
       // it takes more than 1 second due to the overload protection settings.
       EXPECT_TRUE(Time::Now() - start_time_ >= one_second);
       URLFetcherTest::OnURLFetchComplete(source);
     }
   }
 }
 
 void URLFetcherProtectTestPassedThrough::CreateFetcher(const GURL& url) {
   fetcher_ = new URLFetcherImpl(url, URLFetcher::GET, this);
   fetcher_->SetRequestContext(new ThrottlingTestURLRequestContextGetter(
-      io_message_loop_proxy(), request_context()));
+      io_message_loop_proxy().get(), request_context()));
   fetcher_->SetAutomaticallyRetryOn5xx(false);
   start_time_ = Time::Now();
   fetcher_->SetMaxRetriesOn5xx(11);
   fetcher_->Start();
 }
 
 void URLFetcherProtectTestPassedThrough::OnURLFetchComplete(
     const URLFetcher* source) {
   const TimeDelta one_minute = TimeDelta::FromMilliseconds(60000);
   if (source->GetResponseCode() >= 500) {
@@ skipping 38 matching lines @@
   EXPECT_TRUE(source->GetCookies().empty());
   std::string data;
   EXPECT_TRUE(source->GetResponseAsString(&data));
   EXPECT_TRUE(data.empty());
   CleanupAfterFetchComplete();
 }
 
 void URLFetcherCancelTest::CreateFetcher(const GURL& url) {
   fetcher_ = new URLFetcherImpl(url, URLFetcher::GET, this);
   CancelTestURLRequestContextGetter* context_getter =
-      new CancelTestURLRequestContextGetter(io_message_loop_proxy(),
-                                            url);
+      new CancelTestURLRequestContextGetter(io_message_loop_proxy().get(), url);
   fetcher_->SetRequestContext(context_getter);
   fetcher_->SetMaxRetriesOn5xx(2);
   fetcher_->Start();
   // We need to wait for the creation of the URLRequestContext, since we
   // rely on it being destroyed as a signal to end the test.
   context_getter->WaitForContextCreation();
   CancelRequest();
 }
 
 void URLFetcherCancelTest::OnURLFetchComplete(
@@ skipping 13 matching lines @@
 void URLFetcherMultipleAttemptTest::OnURLFetchComplete(
     const URLFetcher* source) {
   EXPECT_TRUE(source->GetStatus().is_success());
   EXPECT_EQ(200, source->GetResponseCode());  // HTTP OK
   std::string data;
   EXPECT_TRUE(source->GetResponseAsString(&data));
   EXPECT_FALSE(data.empty());
   if (!data.empty() && data_.empty()) {
     data_ = data;
     fetcher_->SetRequestContext(new ThrottlingTestURLRequestContextGetter(
-        io_message_loop_proxy(), request_context()));
+        io_message_loop_proxy().get(), request_context()));
     fetcher_->Start();
   } else {
     EXPECT_EQ(data, data_);
     CleanupAfterFetchComplete();
   }
 }
 
 void URLFetcherFileTest::CreateFetcherForFile(const GURL& url,
                                               const base::FilePath& file_path) {
   fetcher_ = new URLFetcherImpl(url, URLFetcher::GET, this);
   fetcher_->SetRequestContext(new ThrottlingTestURLRequestContextGetter(
-      io_message_loop_proxy(), request_context()));
+      io_message_loop_proxy().get(), request_context()));
 
   // Use the IO message loop to do the file operations in this test.
   fetcher_->SaveResponseToFileAtPath(file_path, io_message_loop_proxy());
   fetcher_->Start();
 }
 
 void URLFetcherFileTest::CreateFetcherForTempFile(const GURL& url) {
   fetcher_ = new URLFetcherImpl(url, URLFetcher::GET, this);
   fetcher_->SetRequestContext(new ThrottlingTestURLRequestContextGetter(
-      io_message_loop_proxy(), request_context()));
+      io_message_loop_proxy().get(), request_context()));
 
   // Use the IO message loop to do the file operations in this test.
   fetcher_->SaveResponseToTemporaryFile(io_message_loop_proxy());
   fetcher_->Start();
 }
 
 void URLFetcherFileTest::OnURLFetchComplete(const URLFetcher* source) {
   if (expected_file_error_ == OK) {
     EXPECT_TRUE(source->GetStatus().is_success());
     EXPECT_EQ(source->GetResponseCode(), 200);
@@ skipping 648 matching lines @@
   base::MessageLoop::current()->Run();  // OnURLFetchComplete() will Quit().
 
   base::MessageLoop::current()->RunUntilIdle();
   ASSERT_FALSE(file_util::PathExists(file_path_)) << file_path_.value()
                                                   << " not removed.";
 }
 
 }  // namespace
 
 }  // namespace net