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

webkit/browser/blob/blob_url_request_job.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/browser/blob/blob_url_request_job.h"
 
 #include <limits>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 62 matching lines @@
       file_system_context_(file_system_context),
       file_thread_proxy_(file_thread_proxy),
       total_size_(0),
       remaining_bytes_(0),
       pending_get_file_info_count_(0),
       current_item_index_(0),
       current_item_offset_(0),
       error_(false),
       headers_set_(false),
       byte_range_set_(false) {
-  DCHECK(file_thread_proxy_);
+  DCHECK(file_thread_proxy_.get());
 }
 
 void BlobURLRequestJob::Start() {
   // Continue asynchronously.
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&BlobURLRequestJob::DidStart, weak_factory_.GetWeakPtr()));
 }
 
 void BlobURLRequestJob::Kill() {
@@ skipping 20 matching lines @@
     dest_size = static_cast<int>(remaining_bytes_);
 
   // If we should copy zero bytes because |remaining_bytes_| is zero, short
   // circuit here.
   if (!dest_size) {
     *bytes_read = 0;
     return true;
   }
 
   // Keep track of the buffer.
-  DCHECK(!read_buf_);
+  DCHECK(!read_buf_.get());
   read_buf_ = new net::DrainableIOBuffer(dest, dest_size);
 
   return ReadLoop(bytes_read);
 }
 
 bool BlobURLRequestJob::GetMimeType(std::string* mime_type) const {
   if (!response_info_)
     return false;
 
   return response_info_->headers->GetMimeType(mime_type);
@@ skipping 36 matching lines @@
 }
 
 void BlobURLRequestJob::DidStart() {
   // We only support GET request per the spec.
   if (request()->method() != "GET") {
     NotifyFailure(net::ERR_METHOD_NOT_SUPPORTED);
     return;
   }
 
   // If the blob data is not present, bail out.
-  if (!blob_data_) {
+  if (!blob_data_.get()) {
     NotifyFailure(net::ERR_FILE_NOT_FOUND);
     return;
   }
 
   CountSize();
 }
 
 bool BlobURLRequestJob::AddItemLength(size_t index, int64 item_length) {
   if (item_length > kint64max - total_size_) {
     NotifyFailure(net::ERR_FAILED);
@@ skipping 193 matching lines @@
 
   AdvanceBytesRead(bytes_to_read);
   return true;
 }
 
 bool BlobURLRequestJob::ReadFileItem(FileStreamReader* reader,
                                      int bytes_to_read) {
   DCHECK_GE(read_buf_->BytesRemaining(), bytes_to_read);
   DCHECK(reader);
   const int result = reader->Read(
-      read_buf_, bytes_to_read,
-      base::Bind(&BlobURLRequestJob::DidReadFile,
-                 base::Unretained(this)));
+      read_buf_.get(),
+      bytes_to_read,
+      base::Bind(&BlobURLRequestJob::DidReadFile, base::Unretained(this)));
   if (result >= 0) {
     // Data is immediately available.
     if (GetStatus().is_io_pending())
       DidReadFile(result);
     else
       AdvanceBytesRead(result);
     return true;
   }
   if (result == net::ERR_IO_PENDING)
     SetStatus(net::URLRequestStatus(net::URLRequestStatus::IO_PENDING, 0));
@@ skipping 170 matching lines @@
 void BlobURLRequestJob::CreateFileStreamReader(size_t index,
                                                int64 additional_offset) {
   DCHECK_LT(index, blob_data_->items().size());
   const BlobData::Item& item = blob_data_->items().at(index);
   DCHECK(IsFileType(item.type()));
   DCHECK_EQ(0U, index_to_reader_.count(index));
 
   FileStreamReader* reader = NULL;
   switch (item.type()) {
     case BlobData::Item::TYPE_FILE:
-      reader = new LocalFileStreamReader(
-          file_thread_proxy_,
-          item.path(),
-          item.offset() + additional_offset,
-          item.expected_modification_time());
+      reader = new LocalFileStreamReader(file_thread_proxy_.get(),
+                                         item.path(),
+                                         item.offset() + additional_offset,
+                                         item.expected_modification_time());
       break;
     case BlobData::Item::TYPE_FILE_FILESYSTEM:
       reader = file_system_context_->CreateFileStreamReader(
           fileapi::FileSystemURL(file_system_context_->CrackURL(item.url())),
           item.offset() + additional_offset,
           item.expected_modification_time()).release();
       break;
     default:
       NOTREACHED();
   }
   DCHECK(reader);
   index_to_reader_[index] = reader;
 }
 
 }  // namespace webkit_blob