Remove implicit conversions from scoped_refptr to T* in content/browser/dom_storage/

content/browser/dom_storage/dom_storage_namespace.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 "content/browser/dom_storage/dom_storage_namespace.h"
 
 #include <set>
 #include <utility>
 
 #include "base/basictypes.h"
@@ skipping 45 matching lines @@
       must_persist_at_shutdown_(false) {
   DCHECK_NE(kLocalStorageNamespaceId, namespace_id);
 }
 
 DOMStorageNamespace::~DOMStorageNamespace() {
   STLDeleteValues(&transactions_);
   DecrementMasterAliasCount();
 }
 
 DOMStorageArea* DOMStorageNamespace::OpenStorageArea(const GURL& origin) {
-  if (alias_master_namespace_)
+  if (alias_master_namespace_.get())
     return alias_master_namespace_->OpenStorageArea(origin);
   if (AreaHolder* holder = GetAreaHolder(origin)) {
     ++(holder->open_count_);
     return holder->area_.get();
   }
   DOMStorageArea* area;
   if (namespace_id_ == kLocalStorageNamespaceId) {
     area = new DOMStorageArea(origin, directory_, task_runner_.get());
   } else {
     area = new DOMStorageArea(
         namespace_id_, persistent_namespace_id_, origin,
         session_storage_database_.get(), task_runner_.get());
   }
   areas_[origin] = AreaHolder(area, 1);
   return area;
 }
 
 void DOMStorageNamespace::CloseStorageArea(DOMStorageArea* area) {
   AreaHolder* holder = GetAreaHolder(area->origin());
-  if (alias_master_namespace_) {
+  if (alias_master_namespace_.get()) {
     DCHECK(!holder);
     if (old_master_for_close_area_)
       old_master_for_close_area_->CloseStorageArea(area);
     else
       alias_master_namespace_->CloseStorageArea(area);
     return;
   }
   DCHECK(holder);
   DCHECK_EQ(holder->area_.get(), area);
   --(holder->open_count_);
   // TODO(michaeln): Clean up areas that aren't needed in memory anymore.
   // The in-process-webkit based impl didn't do this either, but would be nice.
 }
 
 DOMStorageArea* DOMStorageNamespace::GetOpenStorageArea(const GURL& origin) {
-  if (alias_master_namespace_)
+  if (alias_master_namespace_.get())
     return alias_master_namespace_->GetOpenStorageArea(origin);
   AreaHolder* holder = GetAreaHolder(origin);
   if (holder && holder->open_count_)
     return holder->area_.get();
   return NULL;
 }
 
 DOMStorageNamespace* DOMStorageNamespace::Clone(
     int64 clone_namespace_id,
     const std::string& clone_persistent_namespace_id) {
-  if (alias_master_namespace_) {
+  if (alias_master_namespace_.get()) {
     return alias_master_namespace_->Clone(clone_namespace_id,
                                           clone_persistent_namespace_id);
   }
   DCHECK_NE(kLocalStorageNamespaceId, namespace_id_);
   DCHECK_NE(kLocalStorageNamespaceId, clone_namespace_id);
   DOMStorageNamespace* clone = new DOMStorageNamespace(
       clone_namespace_id, clone_persistent_namespace_id,
       session_storage_database_.get(), task_runner_.get());
   AreaMap::const_iterator it = areas_.begin();
   // Clone the in-memory structures.
@@ skipping 22 matching lines @@
   // the alias will never open any areas of its own, but always redirect
   // to the master). Accordingly, an alias will also never undergo the shutdown
   // procedure which initiates persisting to disk, since there is never any data
   // of its own to persist to disk. DOMStorageContextImpl is the place where
   // shutdowns are initiated, but only for non-alias DOMStorageNamespaces.
   DCHECK_NE(kLocalStorageNamespaceId, namespace_id_);
   DCHECK_NE(kLocalStorageNamespaceId, alias_namespace_id);
   DOMStorageNamespace* alias = new DOMStorageNamespace(
       alias_namespace_id, persistent_namespace_id_,
       session_storage_database_.get(), task_runner_.get());
-  if (alias_master_namespace_ != NULL) {
-    DCHECK(alias_master_namespace_->alias_master_namespace_ == NULL);
+  if (alias_master_namespace_.get() != NULL) {
+    DCHECK(alias_master_namespace_->alias_master_namespace_.get() == NULL);
     alias->alias_master_namespace_ = alias_master_namespace_;
   } else {
     alias->alias_master_namespace_ = this;
   }
   alias->alias_master_namespace_->num_aliases_++;
   return alias;
 }
 
 void DOMStorageNamespace::DeleteLocalStorageOrigin(const GURL& origin) {
   DCHECK(!session_storage_database_.get());
   DCHECK(!alias_master_namespace_.get());
   AreaHolder* holder = GetAreaHolder(origin);
   if (holder) {
     holder->area_->DeleteOrigin();
     return;
   }
   if (!directory_.empty()) {
     scoped_refptr<DOMStorageArea> area =
         new DOMStorageArea(origin, directory_, task_runner_.get());
     area->DeleteOrigin();
   }
 }
 
 void DOMStorageNamespace::DeleteSessionStorageOrigin(const GURL& origin) {
-  if (alias_master_namespace_) {
+  if (alias_master_namespace_.get()) {
     alias_master_namespace_->DeleteSessionStorageOrigin(origin);
     return;
   }
   DOMStorageArea* area = OpenStorageArea(origin);
   area->FastClear();
   CloseStorageArea(area);
 }
 
 void DOMStorageNamespace::PurgeMemory(PurgeOption option) {
-  if (alias_master_namespace_) {
+  if (alias_master_namespace_.get()) {
     alias_master_namespace_->PurgeMemory(option);
     return;
   }
   if (directory_.empty())
     return;  // We can't purge w/o backing on disk.
   AreaMap::iterator it = areas_.begin();
   while (it != areas_.end()) {
     // Leave it alone if changes are pending
     if (it->second.area_->HasUncommittedChanges()) {
       ++it;
@@ skipping 18 matching lines @@
   }
 }
 
 void DOMStorageNamespace::Shutdown() {
   AreaMap::const_iterator it = areas_.begin();
   for (; it != areas_.end(); ++it)
     it->second.area_->Shutdown();
 }
 
 unsigned int DOMStorageNamespace::CountInMemoryAreas() const {
-  if (alias_master_namespace_)
+  if (alias_master_namespace_.get())
     return alias_master_namespace_->CountInMemoryAreas();
   unsigned int area_count = 0;
   for (AreaMap::const_iterator it = areas_.begin(); it != areas_.end(); ++it) {
     if (it->second.area_->IsLoadedInMemory())
       ++area_count;
   }
   return area_count;
 }
 
 DOMStorageNamespace::AreaHolder*
@@ skipping 126 matching lines @@
   if (transaction_data->max_log_size_exceeded)
     return;
   transaction_data->log.push_back(transaction);
   if (transaction_data->log.size() > kMaxTransactionLogEntries) {
     transaction_data->max_log_size_exceeded = true;
     transaction_data->log.clear();
   }
 }
 
 bool DOMStorageNamespace::DecrementMasterAliasCount() {
-  if (!alias_master_namespace_ || master_alias_count_decremented_)
+  if (!alias_master_namespace_.get() || master_alias_count_decremented_)
     return false;
   DCHECK_GT(alias_master_namespace_->num_aliases_, 0);
   alias_master_namespace_->num_aliases_--;
   master_alias_count_decremented_ = true;
   return (alias_master_namespace_->num_aliases_ == 0);
 }
 
 void DOMStorageNamespace::SwitchToNewAliasMaster(
     DOMStorageNamespace* new_master,
     DOMStorageContextImpl* context) {
   DCHECK(alias_master_namespace());
   scoped_refptr<DOMStorageNamespace> old_master = alias_master_namespace();
   if (new_master->alias_master_namespace())
     new_master = new_master->alias_master_namespace();
   DCHECK(!new_master->alias_master_namespace());
-  DCHECK(old_master != this);
-  DCHECK(old_master != new_master);
+  DCHECK(old_master.get() != this);
+  DCHECK(old_master.get() != new_master);
   DecrementMasterAliasCount();
   alias_master_namespace_ = new_master;
   alias_master_namespace_->num_aliases_++;
   master_alias_count_decremented_ = false;
   // There are three things that we need to clean up:
   // -- the old master may ready for shutdown, if its last alias has disappeared
   // -- The dom_storage hosts need to close and reopen their areas, so that
   // they point to the correct new areas.
   // -- The renderers will need to reset their local caches.
   // All three of these things are accomplished with the following call below.
@@ skipping 29 matching lines @@
 
 DOMStorageNamespace::AreaHolder::AreaHolder(
     DOMStorageArea* area, int count)
     : area_(area), open_count_(count) {
 }
 
 DOMStorageNamespace::AreaHolder::~AreaHolder() {
 }
 
 }  // namespace content