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

webkit/browser/database/database_tracker.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 "webkit/browser/database/database_tracker.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 102 matching lines @@
 void DatabaseTracker::DatabaseOpened(const base::string16& origin_identifier,
                                      const base::string16& database_name,
                                      const base::string16& database_description,
                                      int64 estimated_size,
                                      int64* database_size) {
   if (shutting_down_ || !LazyInit()) {
     *database_size = 0;
     return;
   }
 
-  if (quota_manager_proxy_)
+  if (quota_manager_proxy_.get())
     quota_manager_proxy_->NotifyStorageAccessed(
         quota::QuotaClient::kDatabase,
         webkit_base::GetOriginURLFromIdentifier(origin_identifier),
         quota::kStorageTypeTemporary);
 
   InsertOrUpdateDatabaseDetails(origin_identifier, database_name,
                                 database_description, estimated_size);
   if (database_connections_.AddConnection(origin_identifier, database_name)) {
     *database_size = SeedOpenDatabaseInfo(origin_identifier,
                                           database_name,
@@ skipping 14 matching lines @@
 
 void DatabaseTracker::DatabaseClosed(const base::string16& origin_identifier,
                                      const base::string16& database_name) {
   if (database_connections_.IsEmpty()) {
     DCHECK(!is_initialized_);
     return;
   }
 
   // We call NotifiyStorageAccessed when a db is opened and also when
   // closed because we don't call it for read while open.
-  if (quota_manager_proxy_)
+  if (quota_manager_proxy_.get())
     quota_manager_proxy_->NotifyStorageAccessed(
         quota::QuotaClient::kDatabase,
         webkit_base::GetOriginURLFromIdentifier(origin_identifier),
         quota::kStorageTypeTemporary);
 
   UpdateOpenDatabaseSizeAndNotify(origin_identifier, database_name);
   if (database_connections_.RemoveConnection(origin_identifier, database_name))
     DeleteDatabaseIfNeeded(origin_identifier, database_name);
 }
 
@@ skipping 177 matching lines @@
 bool DatabaseTracker::DeleteClosedDatabase(
     const base::string16& origin_identifier,
     const base::string16& database_name) {
   if (!LazyInit())
     return false;
 
   // Check if the database is opened by any renderer.
   if (database_connections_.IsDatabaseOpened(origin_identifier, database_name))
     return false;
 
-  int64 db_file_size = quota_manager_proxy_ ?
-      GetDBFileSize(origin_identifier, database_name) : 0;
+  int64 db_file_size = quota_manager_proxy_.get()
+                           ? GetDBFileSize(origin_identifier, database_name)
+                           : 0;
 
   // Try to delete the file on the hard drive.
   base::FilePath db_file = GetFullDBFilePath(origin_identifier, database_name);
   if (file_util::PathExists(db_file) && !file_util::Delete(db_file, false))
     return false;
 
   // Also delete any orphaned journal file.
   DCHECK(db_file.Extension().empty());
   file_util::Delete(db_file.InsertBeforeExtensionASCII(
       DatabaseUtil::kJournalFileSuffix), false);
 
-  if (quota_manager_proxy_ && db_file_size)
+  if (quota_manager_proxy_.get() && db_file_size)
     quota_manager_proxy_->NotifyStorageModified(
         quota::QuotaClient::kDatabase,
         webkit_base::GetOriginURLFromIdentifier(origin_identifier),
         quota::kStorageTypeTemporary,
         -db_file_size);
 
   // Clean up the main database and invalidate the cached record.
   databases_table_->DeleteDatabaseDetails(origin_identifier, database_name);
   origins_info_map_.erase(origin_identifier);
 
   std::vector<DatabaseDetails> details;
   if (databases_table_->GetAllDatabaseDetailsForOrigin(
           origin_identifier, &details) && details.empty()) {
     // Try to delete the origin in case this was the last database.
     DeleteOrigin(origin_identifier, false);
   }
   return true;
 }
 
 bool DatabaseTracker::DeleteOrigin(const base::string16& origin_identifier,
                                    bool force) {
   if (!LazyInit())
     return false;
 
   // Check if any database in this origin is opened by any renderer.
   if (database_connections_.IsOriginUsed(origin_identifier) && !force)
     return false;
 
   int64 deleted_size = 0;
-  if (quota_manager_proxy_) {
+  if (quota_manager_proxy_.get()) {
     CachedOriginInfo* origin_info = GetCachedOriginInfo(origin_identifier);
     if (origin_info)
       deleted_size = origin_info->TotalSize();
   }
 
   origins_info_map_.erase(origin_identifier);
   base::FilePath origin_dir = db_dir_.Append(base::FilePath::FromWStringHack(
       UTF16ToWide(origin_identifier)));
 
   // Create a temporary directory to move possibly still existing databases to,
@@ skipping 10 matching lines @@
   for (base::FilePath database = databases.Next(); !database.empty();
        database = databases.Next()) {
     base::FilePath new_file = new_origin_dir.Append(database.BaseName());
     file_util::Move(database, new_file);
   }
   file_util::Delete(origin_dir, true);
   file_util::Delete(new_origin_dir, true); // might fail on windows.
 
   databases_table_->DeleteOrigin(origin_identifier);
 
-  if (quota_manager_proxy_ && deleted_size) {
+  if (quota_manager_proxy_.get() && deleted_size) {
     quota_manager_proxy_->NotifyStorageModified(
         quota::QuotaClient::kDatabase,
         webkit_base::GetOriginURLFromIdentifier(origin_identifier),
         quota::kStorageTypeTemporary,
         -deleted_size);
   }
 
   return true;
 }
 
@@ skipping 166 matching lines @@
   DCHECK(database_connections_.IsDatabaseOpened(origin_id, name));
   int64 new_size = GetDBFileSize(origin_id, name);
   int64 old_size = database_connections_.GetOpenDatabaseSize(origin_id, name);
   CachedOriginInfo* info = MaybeGetCachedOriginInfo(origin_id, false);
   if (info && opt_description)
     info->SetDatabaseDescription(name, *opt_description);
   if (old_size != new_size) {
     database_connections_.SetOpenDatabaseSize(origin_id, name, new_size);
     if (info)
       info->SetDatabaseSize(name, new_size);
-    if (quota_manager_proxy_)
+    if (quota_manager_proxy_.get())
       quota_manager_proxy_->NotifyStorageModified(
           quota::QuotaClient::kDatabase,
           webkit_base::GetOriginURLFromIdentifier(origin_id),
           quota::kStorageTypeTemporary,
           new_size - old_size);
     FOR_EACH_OBSERVER(Observer, observers_, OnDatabaseSizeChanged(
         origin_id, name, new_size));
   }
   return new_size;
 }
@@ skipping 241 matching lines @@
   if (!db_tracker_thread_->BelongsToCurrentThread()) {
     db_tracker_thread_->PostTask(
         FROM_HERE,
         base::Bind(&DatabaseTracker::SetForceKeepSessionState, this));
     return;
   }
   force_keep_session_state_ = true;
 }
 
 }  // namespace webkit_database