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

webkit/appcache/appcache_host_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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "net/url_request/url_request.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 171 matching lines @@
 
   last_swap_result_ = true;
   host.SwapCacheWithCallback(swap_cache_callback_, reinterpret_cast<void*>(3));
   EXPECT_FALSE(last_swap_result_);
   EXPECT_EQ(reinterpret_cast<void*>(3), last_callback_param_);
 }
 
 TEST_F(AppCacheHostTest, SelectNoCache) {
   scoped_refptr<MockQuotaManagerProxy> mock_quota_proxy(
       new MockQuotaManagerProxy);
-  service_.set_quota_manager_proxy(mock_quota_proxy);
+  service_.set_quota_manager_proxy(mock_quota_proxy.get());
 
   // Reset our mock frontend
   mock_frontend_.last_cache_id_ = -333;
   mock_frontend_.last_host_id_ = -333;
   mock_frontend_.last_status_ = OBSOLETE;
 
   const GURL kDocAndOriginUrl(GURL("http://whatever/").GetOrigin());
   {
     AppCacheHost host(1, &mock_frontend_, &service_);
     host.SelectCache(kDocAndOriginUrl, kNoCacheId, GURL());
@@ skipping 140 matching lines @@
   EXPECT_EQ(reinterpret_cast<void*>(1), last_callback_param_);
 }
 
 TEST_F(AppCacheHostTest, SetSwappableCache) {
   AppCacheHost host(1, &mock_frontend_, &service_);
   host.SetSwappableCache(NULL);
   EXPECT_FALSE(host.swappable_cache_.get());
 
   scoped_refptr<AppCacheGroup> group1(new AppCacheGroup(
       service_.storage(), GURL(), service_.storage()->NewGroupId()));
-  host.SetSwappableCache(group1);
+  host.SetSwappableCache(group1.get());
   EXPECT_FALSE(host.swappable_cache_.get());
 
   AppCache* cache1 = new AppCache(service_.storage(), 111);
   cache1->set_complete(true);
   group1->AddCache(cache1);
-  host.SetSwappableCache(group1);
+  host.SetSwappableCache(group1.get());
   EXPECT_EQ(cache1, host.swappable_cache_.get());
 
   mock_frontend_.last_host_id_ = -222;  // to verify we received OnCacheSelected
 
   host.AssociateCompleteCache(cache1);
   EXPECT_FALSE(host.swappable_cache_.get());  // was same as associated cache
   EXPECT_EQ(appcache::IDLE, host.GetStatus());
   // verify OnCacheSelected was called
   EXPECT_EQ(host.host_id(), mock_frontend_.last_host_id_);
   EXPECT_EQ(cache1->cache_id(), mock_frontend_.last_cache_id_);
@@ skipping 22 matching lines @@
 
   host.AssociateNoCache(GURL());
   EXPECT_FALSE(host.swappable_cache_.get());
   EXPECT_FALSE(group2->HasCache());  // both caches in group2 have refcount 0
 
   // Host adds reference to newest cache when an update is complete.
   AppCache* cache5 = new AppCache(service_.storage(), 555);
   cache5->set_complete(true);
   group2->AddCache(cache5);
   host.group_being_updated_ = group2;
-  host.OnUpdateComplete(group2);
-  EXPECT_FALSE(host.group_being_updated_);
+  host.OnUpdateComplete(group2.get());
+  EXPECT_FALSE(host.group_being_updated_.get());
   EXPECT_EQ(cache5, host.swappable_cache_.get());
 
   group2->RemoveCache(cache5);
   EXPECT_FALSE(group2->HasCache());
   host.group_being_updated_ = group2;
-  host.OnUpdateComplete(group2);
-  EXPECT_FALSE(host.group_being_updated_);
+  host.OnUpdateComplete(group2.get());
+  EXPECT_FALSE(host.group_being_updated_.get());
   EXPECT_FALSE(host.swappable_cache_.get());  // group2 had no newest cache
 }
 
 TEST_F(AppCacheHostTest, ForDedicatedWorker) {
   const int kMockProcessId = 1;
   const int kParentHostId = 1;
   const int kWorkerHostId = 2;
 
   AppCacheBackendImpl backend_impl;
   backend_impl.Initialize(&service_, &mock_frontend_, kMockProcessId);
@@ skipping 22 matching lines @@
   parent_host = NULL;
   EXPECT_EQ(NULL, backend_impl.GetHost(kParentHostId));
   EXPECT_EQ(NULL, worker_host->GetParentAppCacheHost());
 }
 
 TEST_F(AppCacheHostTest, SelectCacheAllowed) {
   scoped_refptr<MockQuotaManagerProxy> mock_quota_proxy(
       new MockQuotaManagerProxy);
   MockAppCachePolicy mock_appcache_policy;
   mock_appcache_policy.can_create_return_value_ = true;
-  service_.set_quota_manager_proxy(mock_quota_proxy);
+  service_.set_quota_manager_proxy(mock_quota_proxy.get());
   service_.set_appcache_policy(&mock_appcache_policy);
 
   // Reset our mock frontend
   mock_frontend_.last_cache_id_ = -333;
   mock_frontend_.last_host_id_ = -333;
   mock_frontend_.last_status_ = OBSOLETE;
   mock_frontend_.last_event_id_ = OBSOLETE_EVENT;
   mock_frontend_.content_blocked_ = false;
 
   const GURL kDocAndOriginUrl(GURL("http://whatever/").GetOrigin());
@@ skipping 17 matching lines @@
   }
   EXPECT_EQ(0, mock_quota_proxy->GetInUseCount(kDocAndOriginUrl));
   service_.set_quota_manager_proxy(NULL);
 }
 
 TEST_F(AppCacheHostTest, SelectCacheBlocked) {
   scoped_refptr<MockQuotaManagerProxy> mock_quota_proxy(
       new MockQuotaManagerProxy);
   MockAppCachePolicy mock_appcache_policy;
   mock_appcache_policy.can_create_return_value_ = false;
-  service_.set_quota_manager_proxy(mock_quota_proxy);
+  service_.set_quota_manager_proxy(mock_quota_proxy.get());
   service_.set_appcache_policy(&mock_appcache_policy);
 
   // Reset our mock frontend
   mock_frontend_.last_cache_id_ = -333;
   mock_frontend_.last_host_id_ = -333;
   mock_frontend_.last_status_ = OBSOLETE;
   mock_frontend_.last_event_id_ = OBSOLETE_EVENT;
   mock_frontend_.content_blocked_ = false;
 
   const GURL kDocAndOriginUrl(GURL("http://whatever/").GetOrigin());
@@ skipping 19 matching lines @@
     EXPECT_EQ(&mock_frontend_, host.frontend());
     EXPECT_EQ(NULL, host.associated_cache());
     EXPECT_FALSE(host.is_selection_pending());
     EXPECT_TRUE(host.preferred_manifest_url().is_empty());
   }
   EXPECT_EQ(0, mock_quota_proxy->GetInUseCount(kDocAndOriginUrl));
   service_.set_quota_manager_proxy(NULL);
 }
 
 }  // namespace appcache