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

webkit/browser/quota/quota_manager.cc

 // Copyright 2013 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 "webkit/browser/quota/quota_manager.h"
 
 #include <algorithm>
 #include <deque>
 #include <functional>
 #include <set>
@@ skipping 930 matching lines @@
 
   HostDataDeleter* deleter =
       new HostDataDeleter(this, host, type, quota_client_mask, callback);
   deleter->Start();
 }
 
 void QuotaManager::GetAvailableSpace(const AvailableSpaceCallback& callback) {
   if (!available_space_callbacks_.Add(callback))
     return;
 
-  PostTaskAndReplyWithResult(
-      db_thread_,
-      FROM_HERE,
-      base::Bind(get_disk_space_fn_, profile_path_),
-      base::Bind(&QuotaManager::DidGetAvailableSpace,
-                 weak_factory_.GetWeakPtr()));
+  PostTaskAndReplyWithResult(db_thread_.get(),
+                             FROM_HERE,
+                             base::Bind(get_disk_space_fn_, profile_path_),
+                             base::Bind(&QuotaManager::DidGetAvailableSpace,
+                                        weak_factory_.GetWeakPtr()));
 }
 
 void QuotaManager::GetTemporaryGlobalQuota(const QuotaCallback& callback) {
   LazyInitialize();
   if (!temporary_quota_initialized_) {
     db_initialization_callbacks_.Add(base::Bind(
         &QuotaManager::GetTemporaryGlobalQuota,
         weak_factory_.GetWeakPtr(), callback));
     return;
   }
@@ skipping 150 matching lines @@
                  callback,
                  type));
 }
 
 bool QuotaManager::ResetUsageTracker(StorageType type) {
   DCHECK(GetUsageTracker(type));
   if (GetUsageTracker(type)->IsWorking())
     return false;
   switch (type) {
     case kStorageTypeTemporary:
-      temporary_usage_tracker_.reset(
-          new UsageTracker(clients_, kStorageTypeTemporary,
-                           special_storage_policy_));
+      temporary_usage_tracker_.reset(new UsageTracker(
+          clients_, kStorageTypeTemporary, special_storage_policy_.get()));
       return true;
     case kStorageTypePersistent:
-      persistent_usage_tracker_.reset(
-          new UsageTracker(clients_, kStorageTypePersistent,
-                           special_storage_policy_));
+      persistent_usage_tracker_.reset(new UsageTracker(
+          clients_, kStorageTypePersistent, special_storage_policy_.get()));
       return true;
     case kStorageTypeSyncable:
-      syncable_usage_tracker_.reset(
-          new UsageTracker(clients_, kStorageTypeSyncable,
-                           special_storage_policy_));
+      syncable_usage_tracker_.reset(new UsageTracker(
+          clients_, kStorageTypeSyncable, special_storage_policy_.get()));
       return true;
     default:
       NOTREACHED();
   }
   return true;
 }
 
 QuotaManager::~QuotaManager() {
   proxy_->manager_ = NULL;
   std::for_each(clients_.begin(), clients_.end(),
@@ skipping 13 matching lines @@
   DCHECK(io_thread_->BelongsToCurrentThread());
   if (database_) {
     // Initialization seems to be done already.
     return;
   }
 
   // Use an empty path to open an in-memory only databse for incognito.
   database_.reset(new QuotaDatabase(is_incognito_ ? base::FilePath() :
       profile_path_.AppendASCII(kDatabaseName)));
 
-  temporary_usage_tracker_.reset(
-      new UsageTracker(clients_, kStorageTypeTemporary,
-                       special_storage_policy_));
-  persistent_usage_tracker_.reset(
-      new UsageTracker(clients_, kStorageTypePersistent,
-                       special_storage_policy_));
-  syncable_usage_tracker_.reset(
-      new UsageTracker(clients_, kStorageTypeSyncable,
-                       special_storage_policy_));
+  temporary_usage_tracker_.reset(new UsageTracker(
+      clients_, kStorageTypeTemporary, special_storage_policy_.get()));
+  persistent_usage_tracker_.reset(new UsageTracker(
+      clients_, kStorageTypePersistent, special_storage_policy_.get()));
+  syncable_usage_tracker_.reset(new UsageTracker(
+      clients_, kStorageTypeSyncable, special_storage_policy_.get()));
 
   int64* temporary_quota_override = new int64(-1);
   int64* desired_available_space = new int64(-1);
   PostTaskAndReplyWithResultForDBThread(
       FROM_HERE,
       base::Bind(&InitializeOnDBThread,
                  base::Unretained(temporary_quota_override),
                  base::Unretained(desired_available_space)),
       base::Bind(&QuotaManager::DidInitialize,
                  weak_factory_.GetWeakPtr(),
@@ skipping 141 matching lines @@
     int64 usage,
     int64 unlimited_usage) {
   UMA_HISTOGRAM_MBYTES("Quota.GlobalUsageOfTemporaryStorage", usage);
 
   std::set<GURL> origins;
   GetCachedOrigins(kStorageTypeTemporary, &origins);
 
   size_t num_origins = origins.size();
   size_t protected_origins = 0;
   size_t unlimited_origins = 0;
-  CountOriginType(origins, special_storage_policy_,
-                  &protected_origins, &unlimited_origins);
+  CountOriginType(origins,
+                  special_storage_policy_.get(),
+                  &protected_origins,
+                  &unlimited_origins);
 
   UMA_HISTOGRAM_COUNTS("Quota.NumberOfTemporaryStorageOrigins",
                        num_origins);
   UMA_HISTOGRAM_COUNTS("Quota.NumberOfProtectedTemporaryStorageOrigins",
                        protected_origins);
   UMA_HISTOGRAM_COUNTS("Quota.NumberOfUnlimitedTemporaryStorageOrigins",
                        unlimited_origins);
 }
 
 void QuotaManager::DidGetPersistentGlobalUsageForHistogram(
     int64 usage,
     int64 unlimited_usage) {
   UMA_HISTOGRAM_MBYTES("Quota.GlobalUsageOfPersistentStorage", usage);
 
   std::set<GURL> origins;
   GetCachedOrigins(kStorageTypePersistent, &origins);
 
   size_t num_origins = origins.size();
   size_t protected_origins = 0;
   size_t unlimited_origins = 0;
-  CountOriginType(origins, special_storage_policy_,
-                  &protected_origins, &unlimited_origins);
+  CountOriginType(origins,
+                  special_storage_policy_.get(),
+                  &protected_origins,
+                  &unlimited_origins);
 
   UMA_HISTOGRAM_COUNTS("Quota.NumberOfPersistentStorageOrigins",
                        num_origins);
   UMA_HISTOGRAM_COUNTS("Quota.NumberOfProtectedPersistentStorageOrigins",
                        protected_origins);
   UMA_HISTOGRAM_COUNTS("Quota.NumberOfUnlimitedPersistentStorageOrigins",
                        unlimited_origins);
 }
 
 void QuotaManager::GetLRUOrigin(
@@ skipping 172 matching lines @@
 }
 
 void QuotaManager::PostTaskAndReplyWithResultForDBThread(
     const tracked_objects::Location& from_here,
     const base::Callback<bool(QuotaDatabase*)>& task,
     const base::Callback<void(bool)>& reply) {
   // Deleting manager will post another task to DB thread to delete
   // |database_|, therefore we can be sure that database_ is alive when this
   // task runs.
   base::PostTaskAndReplyWithResult(
-      db_thread_,
+      db_thread_.get(),
       from_here,
       base::Bind(task, base::Unretained(database_.get())),
       reply);
 }
 
 // QuotaManagerProxy ----------------------------------------------------------
 
 void QuotaManagerProxy::RegisterClient(QuotaClient* client) {
   if (!io_thread_->BelongsToCurrentThread() &&
       io_thread_->PostTask(
@@ skipping 76 matching lines @@
         FROM_HERE,
         base::Bind(&QuotaManagerProxy::SetUsageCacheEnabled, this,
                    client_id, origin, type, enabled));
     return;
   }
   if (manager_)
     manager_->SetUsageCacheEnabled(client_id, origin, type, enabled);
 }
 
 QuotaManager* QuotaManagerProxy::quota_manager() const {
-  DCHECK(!io_thread_ || io_thread_->BelongsToCurrentThread());
+  DCHECK(!io_thread_.get() || io_thread_->BelongsToCurrentThread());
   return manager_;
 }
 
 QuotaManagerProxy::QuotaManagerProxy(
     QuotaManager* manager, base::SingleThreadTaskRunner* io_thread)
     : manager_(manager), io_thread_(io_thread) {
 }
 
 QuotaManagerProxy::~QuotaManagerProxy() {
 }
 
 }  // namespace quota