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

net/disk_cache/backend_impl.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 "net/disk_cache/backend_impl.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
@@ skipping 589 matching lines @@
     block_files_.DeleteBlock(entry_address, false);
     block_files_.DeleteBlock(node_address, false);
     LOG(ERROR) << "Create entry failed " << key.c_str();
     stats_.OnEvent(Stats::CREATE_ERROR);
     return NULL;
   }
 
   cache_entry->BeginLogging(net_log_, true);
 
   // We are not failing the operation; let's add this to the map.
-  open_entries_[entry_address.value()] = cache_entry;
+  open_entries_[entry_address.value()] = cache_entry.get();
 
   // Save the entry.
   cache_entry->entry()->Store();
   cache_entry->rankings()->Store();
   IncreaseNumEntries();
   entry_count_++;
 
   // Link this entry through the index.
   if (parent.get()) {
     parent->SetNextAddress(entry_address);
   } else {
     data_->table[hash & mask_] = entry_address.value();
   }
 
   // Link this entry through the lists.
-  eviction_.OnCreateEntry(cache_entry);
+  eviction_.OnCreateEntry(cache_entry.get());
 
   CACHE_UMA(AGE_MS, "CreateTime", 0, start);
   stats_.OnEvent(Stats::CREATE_HIT);
   SIMPLE_STATS_COUNTER("disk_cache.miss");
   Trace("create entry hit ");
   FlushIndex();
   cache_entry->AddRef();
   return cache_entry.get();
 }
 
@@ skipping 502 matching lines @@
     LOG(ERROR) << "Number of entries mismatch";
 #if !defined(NET_BUILD_STRESS_CACHE)
     return ERR_NUM_ENTRIES_MISMATCH;
 #endif
   }
 
   return CheckAllEntries();
 }
 
 void BackendImpl::FlushIndex() {
-  if (index_ && !disabled_)
+  if (index_.get() && !disabled_)
     index_->Flush();
 }
 
 // ------------------------------------------------------------------------
 
 net::CacheType BackendImpl::GetCacheType() const {
   return cache_type_;
 }
 
 int32 BackendImpl::GetEntryCount() const {
-  if (!index_ || disabled_)
+  if (!index_.get() || disabled_)
     return 0;
   // num_entries includes entries already evicted.
   int32 not_deleted = data_->header.num_entries -
                       data_->header.lru.sizes[Rankings::DELETED];
 
   if (not_deleted < 0) {
     NOTREACHED();
     not_deleted = 0;
   }
 
@@ skipping 116 matching lines @@
               base::PLATFORM_FILE_OPEN_ALWAYS |
               base::PLATFORM_FILE_EXCLUSIVE_WRITE;
   scoped_refptr<disk_cache::File> file(new disk_cache::File(
       base::CreatePlatformFile(index_name, flags, file_created, NULL)));
 
   if (!file->IsValid())
     return false;
 
   bool ret = true;
   if (*file_created)
-    ret = CreateBackingStore(file);
+    ret = CreateBackingStore(file.get());
 
   file = NULL;
   if (!ret)
     return false;
 
   index_ = new MappedFile();
   data_ = reinterpret_cast<Index*>(index_->Init(index_name, 0));
   if (!data_) {
     LOG(ERROR) << "Unable to map Index file";
     return false;
@@ skipping 209 matching lines @@
   }
 
   // Prevent overwriting the dirty flag on the destructor.
   cache_entry->SetDirtyFlag(GetCurrentEntryId());
 
   if (cache_entry->dirty()) {
     Trace("Dirty entry 0x%p 0x%x", reinterpret_cast<void*>(cache_entry.get()),
           address.value());
   }
 
-  open_entries_[address.value()] = cache_entry;
+  open_entries_[address.value()] = cache_entry.get();
 
   cache_entry->BeginLogging(net_log_, false);
   cache_entry.swap(entry);
   return 0;
 }
 
 EntryImpl* BackendImpl::MatchEntry(const std::string& key, uint32 hash,
                                    bool find_parent, Addr entry_addr,
                                    bool* match_error) {
   Addr address(data_->table[hash & mask_]);
@@ skipping 25 matching lines @@
     int error = NewEntry(address, &tmp);
     cache_entry.swap(&tmp);
 
     if (error || cache_entry->dirty()) {
       // This entry is dirty on disk (it was not properly closed): we cannot
       // trust it.
       Addr child(0);
       if (!error)
         child.set_value(cache_entry->GetNextAddress());
 
-      if (parent_entry) {
+      if (parent_entry.get()) {
         parent_entry->SetNextAddress(child);
         parent_entry = NULL;
       } else {
         data_->table[hash & mask_] = child.value();
       }
 
       Trace("MatchEntry dirty %d 0x%x 0x%x", find_parent, entry_addr.value(),
             address.value());
 
       if (!error) {
         // It is important to call DestroyInvalidEntry after removing this
         // entry from the table.
-        DestroyInvalidEntry(cache_entry);
+        DestroyInvalidEntry(cache_entry.get());
         cache_entry = NULL;
       } else {
         Trace("NewEntry failed on MatchEntry 0x%x", address.value());
       }
 
       // Restart the search.
       address.set_value(data_->table[hash & mask_]);
       visited.clear();
       continue;
     }
 
     DCHECK_EQ(hash & mask_, cache_entry->entry()->Data()->hash & mask_);
     if (cache_entry->IsSameEntry(key, hash)) {
       if (!cache_entry->Update())
         cache_entry = NULL;
       found = true;
       if (find_parent && entry_addr.value() != address.value()) {
         Trace("Entry not on the index 0x%x", address.value());
         *match_error = true;
         parent_entry = NULL;
       }
       break;
     }
     if (!cache_entry->Update())
       cache_entry = NULL;
     parent_entry = cache_entry;
     cache_entry = NULL;
-    if (!parent_entry)
+    if (!parent_entry.get())
       break;
 
     address.set_value(parent_entry->GetNextAddress());
   }
 
-  if (parent_entry && (!find_parent || !found))
+  if (parent_entry.get() && (!find_parent || !found))
     parent_entry = NULL;
 
-  if (find_parent && entry_addr.is_initialized() && !cache_entry) {
+  if (find_parent && entry_addr.is_initialized() && !cache_entry.get()) {
     *match_error = true;
     parent_entry = NULL;
   }
 
-  if (cache_entry && (find_parent || !found))
+  if (cache_entry.get() && (find_parent || !found))
     cache_entry = NULL;
 
   find_parent ? parent_entry.swap(&tmp) : cache_entry.swap(&tmp);
   FlushIndex();
   return tmp;
 }
 
 // This is the actual implementation for OpenNextEntry and OpenPrevEntry.
 EntryImpl* BackendImpl::OpenFollowingEntry(bool forward, void** iter) {
   if (disabled_)
@@ skipping 466 matching lines @@
     if (total_memory > kMaxBuffersSize || total_memory <= 0)
       total_memory = kMaxBuffersSize;
 
     done = true;
   }
 
   return static_cast<int>(total_memory);
 }
 
 }  // namespace disk_cache