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

webkit/dom_storage/dom_storage_context.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/dom_storage/dom_storage_context.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_util.h"
 #include "base/guid.h"
@@ skipping 25 matching lines @@
       force_keep_session_state_(false),
       special_storage_policy_(special_storage_policy),
       scavenging_started_(false) {
   // AtomicSequenceNum starts at 0 but we want to start session
   // namespace ids at one since zero is reserved for the
   // kLocalStorageNamespaceId.
   session_id_sequence_.GetNext();
 }
 
 DomStorageContext::~DomStorageContext() {
-  if (session_storage_database_) {
+  if (session_storage_database_.get()) {
     // SessionStorageDatabase shouldn't be deleted right away: deleting it will
     // potentially involve waiting in leveldb::DBImpl::~DBImpl, and waiting
     // shouldn't happen on this thread.
     SessionStorageDatabase* to_release = session_storage_database_.get();
     to_release->AddRef();
     session_storage_database_ = NULL;
     task_runner_->PostShutdownBlockingTask(
         FROM_HERE,
         DomStorageTaskRunner::COMMIT_SEQUENCE,
         base::Bind(&SessionStorageDatabase::Release,
                    base::Unretained(to_release)));
   }
 }
 
 DomStorageNamespace* DomStorageContext::GetStorageNamespace(
     int64 namespace_id) {
   if (is_shutdown_)
     return NULL;
   StorageNamespaceMap::iterator found = namespaces_.find(namespace_id);
   if (found == namespaces_.end()) {
     if (namespace_id == kLocalStorageNamespaceId) {
       if (!localstorage_directory_.empty()) {
         if (!file_util::CreateDirectory(localstorage_directory_)) {
           LOG(ERROR) << "Failed to create 'Local Storage' directory,"
                         " falling back to in-memory only.";
           localstorage_directory_ = base::FilePath();
         }
       }
       DomStorageNamespace* local =
-          new DomStorageNamespace(localstorage_directory_, task_runner_);
+          new DomStorageNamespace(localstorage_directory_, task_runner_.get());
       namespaces_[kLocalStorageNamespaceId] = local;
       return local;
     }
     return NULL;
   }
-  return found->second;
+  return found->second.get();
 }
 
 void DomStorageContext::GetLocalStorageUsage(
     std::vector<LocalStorageUsageInfo>* infos,
     bool include_file_info) {
   if (localstorage_directory_.empty())
     return;
   FileEnumerator enumerator(localstorage_directory_, false,
                             FileEnumerator::FILES);
   for (base::FilePath path = enumerator.Next(); !path.empty();
        path = enumerator.Next()) {
     if (path.MatchesExtension(DomStorageArea::kDatabaseFileExtension)) {
       LocalStorageUsageInfo info;
       info.origin = DomStorageArea::OriginFromDatabaseFileName(path);
       if (include_file_info) {
         FileEnumerator::FindInfo find_info;
         enumerator.GetFindInfo(&find_info);
         info.data_size = FileEnumerator::GetFilesize(find_info);
         info.last_modified = FileEnumerator::GetLastModifiedTime(find_info);
       }
       infos->push_back(info);
     }
   }
 }
 
 void DomStorageContext::GetSessionStorageUsage(
     std::vector<SessionStorageUsageInfo>* infos) {
-  if (!session_storage_database_)
+  if (!session_storage_database_.get())
     return;
   std::map<std::string, std::vector<GURL> > namespaces_and_origins;
   session_storage_database_->ReadNamespacesAndOrigins(
       &namespaces_and_origins);
   for (std::map<std::string, std::vector<GURL> >::const_iterator it =
            namespaces_and_origins.begin();
        it != namespaces_and_origins.end(); ++it) {
     for (std::vector<GURL>::const_iterator origin_it = it->second.begin();
          origin_it != it->second.end(); ++origin_it) {
       SessionStorageUsageInfo info;
@@ skipping 48 matching lines @@
   if (found != namespaces_.end())
     found->second->PurgeMemory(DomStorageNamespace::PURGE_AGGRESSIVE);
 }
 
 void DomStorageContext::Shutdown() {
   is_shutdown_ = true;
   StorageNamespaceMap::const_iterator it = namespaces_.begin();
   for (; it != namespaces_.end(); ++it)
     it->second->Shutdown();
 
-  if (localstorage_directory_.empty() && !session_storage_database_)
+  if (localstorage_directory_.empty() && !session_storage_database_.get())
     return;
 
   // Respect the content policy settings about what to
   // keep and what to discard.
   if (force_keep_session_state_)
     return;  // Keep everything.
 
   bool has_session_only_origins =
       special_storage_policy_.get() &&
       special_storage_policy_->HasSessionOnlyOrigins();
@@ skipping 53 matching lines @@
   return guid;
 }
 
 void DomStorageContext::CreateSessionNamespace(
     int64 namespace_id,
     const std::string& persistent_namespace_id) {
   if (is_shutdown_)
     return;
   DCHECK(namespace_id != kLocalStorageNamespaceId);
   DCHECK(namespaces_.find(namespace_id) == namespaces_.end());
-  namespaces_[namespace_id] = new DomStorageNamespace(
-      namespace_id, persistent_namespace_id, session_storage_database_.get(),
-      task_runner_);
+  namespaces_[namespace_id] =
+      new DomStorageNamespace(namespace_id,
+                              persistent_namespace_id,
+                              session_storage_database_.get(),
+                              task_runner_.get());
   persistent_namespace_id_to_namespace_id_[persistent_namespace_id] =
       namespace_id;
 }
 
 void DomStorageContext::DeleteSessionNamespace(
     int64 namespace_id, bool should_persist_data) {
   DCHECK_NE(kLocalStorageNamespaceId, namespace_id);
   StorageNamespaceMap::const_iterator it = namespaces_.find(namespace_id);
   if (it == namespaces_.end())
     return;
   std::string persistent_namespace_id = it->second->persistent_namespace_id();
-  if (session_storage_database_) {
+  if (session_storage_database_.get()) {
     if (!should_persist_data) {
       task_runner_->PostShutdownBlockingTask(
           FROM_HERE,
           DomStorageTaskRunner::COMMIT_SEQUENCE,
           base::Bind(
               base::IgnoreResult(&SessionStorageDatabase::DeleteNamespace),
               session_storage_database_,
               persistent_namespace_id));
     } else {
       // Ensure that the data gets committed before we shut down.
@@ skipping 36 matching lines @@
 
       const bool kNotRecursive = false;
       base::FilePath database_file_path = localstorage_directory_.Append(
           DomStorageArea::DatabaseFileNameFromOrigin(origin));
       file_util::Delete(database_file_path, kNotRecursive);
       file_util::Delete(
           DomStorageDatabase::GetJournalFilePath(database_file_path),
           kNotRecursive);
     }
   }
-  if (session_storage_database_) {
+  if (session_storage_database_.get()) {
     std::vector<SessionStorageUsageInfo> infos;
     GetSessionStorageUsage(&infos);
     for (size_t i = 0; i < infos.size(); ++i) {
       const GURL& origin = infos[i].origin;
       if (special_storage_policy_->IsStorageProtected(origin))
         continue;
       if (!special_storage_policy_->IsStorageSessionOnly(origin))
         continue;
       session_storage_database_->DeleteArea(infos[i].persistent_namespace_id,
                                             origin);
     }
   }
 }
 
 void DomStorageContext::SetSaveSessionStorageOnDisk() {
   DCHECK(namespaces_.empty());
   if (!sessionstorage_directory_.empty()) {
     session_storage_database_ = new SessionStorageDatabase(
         sessionstorage_directory_);
   }
 }
 
 void DomStorageContext::StartScavengingUnusedSessionStorage() {
-  if (session_storage_database_) {
+  if (session_storage_database_.get()) {
     task_runner_->PostDelayedTask(
-        FROM_HERE, base::Bind(&DomStorageContext::FindUnusedNamespaces, this),
+        FROM_HERE,
+        base::Bind(&DomStorageContext::FindUnusedNamespaces, this),
         base::TimeDelta::FromSeconds(kSessionStoraceScavengingSeconds));
   }
 }
 
 void DomStorageContext::FindUnusedNamespaces() {
   DCHECK(session_storage_database_.get());
   if (scavenging_started_)
     return;
   scavenging_started_ = true;
   std::set<std::string> namespace_ids_in_use;
@@ skipping 54 matching lines @@
   if (!deletable_persistent_namespace_ids_.empty()) {
     task_runner_->PostDelayedTask(
         FROM_HERE, base::Bind(
             &DomStorageContext::DeleteNextUnusedNamespace,
             this),
         base::TimeDelta::FromSeconds(kSessionStoraceScavengingSeconds));
   }
 }
 
 }  // namespace dom_storage