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

content/renderer/dom_storage/dom_storage_dispatcher.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 "content/renderer/dom_storage/dom_storage_dispatcher.h"
 
 #include <list>
 #include <map>
 
 #include "base/string_number_conversions.h"
@@ skipping 157 matching lines @@
 
   RenderThreadImpl* sender_;
   CachedAreaMap cached_areas_;
   CallbackList pending_callbacks_;
   scoped_refptr<MessageThrottlingFilter> throttling_filter_;
 };
 
 DomStorageDispatcher::ProxyImpl::ProxyImpl(RenderThreadImpl* sender)
     : sender_(sender),
       throttling_filter_(new MessageThrottlingFilter(sender)) {
-  sender_->AddFilter(throttling_filter_);
+  sender_->AddFilter(throttling_filter_.get());
 }
 
 DomStorageCachedArea* DomStorageDispatcher::ProxyImpl::OpenCachedArea(
     int64 namespace_id, const GURL& origin) {
   std::string key = GetCachedAreaKey(namespace_id, origin);
   if (CachedAreaHolder* holder = GetAreaHolder(key)) {
     ++(holder->open_count_);
-    return holder->area_;
+    return holder->area_.get();
   }
   scoped_refptr<DomStorageCachedArea> area =
       new DomStorageCachedArea(namespace_id, origin, this);
-  cached_areas_[key] = CachedAreaHolder(area, 1);
+  cached_areas_[key] = CachedAreaHolder(area.get(), 1);
   return area.get();
 }
 
 void DomStorageDispatcher::ProxyImpl::CloseCachedArea(
     DomStorageCachedArea* area) {
   std::string key = GetCachedAreaKey(area->namespace_id(), area->origin());
   CachedAreaHolder* holder = GetAreaHolder(key);
   DCHECK(holder);
   DCHECK_EQ(holder->area_.get(), area);
   DCHECK_GT(holder->open_count_, 0);
@@ skipping 10 matching lines @@
     return NULL;
   return holder->area_.get();
 }
 
 void DomStorageDispatcher::ProxyImpl::CompleteOnePendingCallback(bool success) {
   PopPendingCallback().Run(success);
 }
 
 void DomStorageDispatcher::ProxyImpl::Shutdown() {
   throttling_filter_->Shutdown();
-  sender_->RemoveFilter(throttling_filter_);
+  sender_->RemoveFilter(throttling_filter_.get());
   sender_ = NULL;
   cached_areas_.clear();
   pending_callbacks_.clear();
 }
 
 void DomStorageDispatcher::ProxyImpl::LoadArea(
     int connection_id, ValuesMap* values,
     const CompletionCallback& callback) {
   PushPendingCallback(callback);
   throttling_filter_->SendThrottled(new DOMStorageHostMsg_LoadStorageArea(
@@ skipping 99 matching lines @@
         originating_area,
         originated_in_process);
   }
 }
 
 void DomStorageDispatcher::OnAsyncOperationComplete(bool success) {
   proxy_->CompleteOnePendingCallback(success);
 }
 
 }  // namespace content