Remove implicit conversions from scoped_refptr to T* in content/*/service_worker/

content/browser/service_worker/service_worker_cache.cc

 // Copyright 2014 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/service_worker/service_worker_cache.h"
 
 #include <string>
 
 #include "base/files/file_path.h"
 #include "base/guid.h"
@@ skipping 113 matching lines @@
       return;
     }
 
     net::CompletionCallback cache_write_callback =
         base::Bind(&BlobReader::DidWriteDataToEntry,
                    weak_ptr_factory_.GetWeakPtr(),
                    bytes_read);
 
     int rv = entry_->WriteData(INDEX_RESPONSE_BODY,
                                cache_entry_offset_,
-                               buffer_,
+                               buffer_.get(),
                                bytes_read,
                                cache_write_callback,
                                true /* truncate */);
     if (rv != net::ERR_IO_PENDING)
       cache_write_callback.Run(rv);
   }
 
   void DidWriteDataToEntry(int expected_bytes, int rv) {
     if (rv != expected_bytes) {
       callback_.Run(entry_.Pass(), false);
@@ skipping 128 matching lines @@
       base::Bind(PutDidWriteHeaders,
                  response,
                  callback,
                  base::Passed(entry.Pass()),
                  base::Passed(blob_data_handle.Pass()),
                  request_context,
                  buffer->size());
 
   rv = tmp_entry_ptr->WriteData(INDEX_HEADERS,
                                 0 /* offset */,
-                                buffer,
+                                buffer.get(),
                                 buffer->size(),
                                 write_headers_callback,
                                 true /* truncate */);
 
   if (rv != net::ERR_IO_PENDING)
     write_headers_callback.Run(rv);
 }
 
 void PutDidWriteHeaders(ServiceWorkerResponse* response,
                         const ServiceWorkerCache::ErrorCallback& callback,
@@ skipping 190 matching lines @@
   }
 
   // TODO(jkarlin): This copying of the the entire cache response into memory is
   // awful. Create a new interface around SimpleCache that provides access the
   // data directly from the file. See bug http://crbug.com/403493.
   response_context->blob_data->AppendData(response_context->buffer->data(), rv);
   response_context->total_bytes_read += rv;
   int total_bytes_read = response_context->total_bytes_read;
 
   // Grab some pointers before passing them in bind.
-  net::IOBufferWithSize* buffer = response_context->buffer;
+  net::IOBufferWithSize* buffer = response_context->buffer.get();

[dcheng, 2014/08/26 17:10:57]

Note: the tool believes this to be safe because it's not grabbing a pointer to
something on the stack. Please let me know if you believe that the variable type
should change instead.

   disk_cache::Entry* tmp_entry_ptr = entry.get();
 
   net::CompletionCallback read_callback =
       base::Bind(MatchDidReadResponseBodyData,
                  request,
                  callback,
                  blob_storage,
                  base::Passed(entry.Pass()),
                  base::Passed(response.Pass()),
                  base::Passed(response_context.Pass()));
@@ skipping 204 matching lines @@
     const base::FilePath& path,
     net::URLRequestContext* request_context,
     base::WeakPtr<storage::BlobStorageContext> blob_context)
     : path_(path),
       request_context_(request_context),
       blob_storage_context_(blob_context),
       weak_ptr_factory_(this) {
 }
 
 }  // namespace content