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

net/http/http_cache_transaction.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/http/http_cache_transaction.h"
 
 #include "build/build_config.h"
 
 #if defined(OS_POSIX)
 #include <unistd.h>
@@ skipping 342 matching lines @@
 
   if (rv == ERR_IO_PENDING)
     callback_ = callback;
 
   return rv;
 }
 
 int HttpCache::Transaction::RestartWithAuth(
     const AuthCredentials& credentials,
     const CompletionCallback& callback) {
-  DCHECK(auth_response_.headers);
+  DCHECK(auth_response_.headers.get());
   DCHECK(!callback.is_null());
 
   // Ensure that we only have one asynchronous call at a time.
   DCHECK(callback_.is_null());
 
   if (!cache_)
     return ERR_UNEXPECTED;
 
   // Clear the intermediate response since we are going to start over.
   auth_response_ = HttpResponseInfo();
@@ skipping 19 matching lines @@
   DCHECK(!callback.is_null());
 
   DCHECK(callback_.is_null());
 
   if (!cache_)
     return ERR_UNEXPECTED;
 
   // If we have an intermediate auth response at this point, then it means the
   // user wishes to read the network response (the error page).  If there is a
   // previous response in the cache then we should leave it intact.
-  if (auth_response_.headers && mode_ != NONE) {
+  if (auth_response_.headers.get() && mode_ != NONE) {
     UpdateTransactionPattern(PATTERN_NOT_COVERED);
     DCHECK(mode_ & WRITE);
     DoneWritingToEntry(mode_ == READ_WRITE);
     mode_ = NONE;
   }
 
   reading_ = true;
   int rv;
 
   switch (mode_) {
@@ skipping 43 matching lines @@
   if (cache_ && entry_) {
     DCHECK(reading_);
     DCHECK_NE(mode_, UPDATE);
     if (mode_ & WRITE)
       DoneWritingToEntry(true);
   }
 }
 
 const HttpResponseInfo* HttpCache::Transaction::GetResponseInfo() const {
   // Null headers means we encountered an error or haven't a response yet
-  if (auth_response_.headers)
+  if (auth_response_.headers.get())
     return &auth_response_;
-  return (response_.headers || response_.ssl_info.cert ||
-          response_.cert_request_info) ? &response_ : NULL;
+  return (response_.headers.get() || response_.ssl_info.cert.get() ||
+          response_.cert_request_info.get())
+             ? &response_
+             : NULL;
 }
 
 LoadState HttpCache::Transaction::GetLoadState() const {
   LoadState state = GetWriterLoadState();
   if (state != LOAD_STATE_WAITING_FOR_CACHE)
     return state;
 
   if (cache_)
     return cache_->GetLoadStateForPendingTransaction(this);
 
@@ skipping 430 matching lines @@
   DCHECK(!new_response_);
   const HttpResponseInfo* new_response = network_trans_->GetResponseInfo();
 
   if (new_response->headers->response_code() == 401 ||
       new_response->headers->response_code() == 407) {
     auth_response_ = *new_response;
     return OK;
   }
 
   new_response_ = new_response;
-  if (!ValidatePartialResponse() && !auth_response_.headers) {
+  if (!ValidatePartialResponse() && !auth_response_.headers.get()) {
     // Something went wrong with this request and we have to restart it.
     // If we have an authentication response, we are exposed to weird things
     // hapenning if the user cancels the authentication before we receive
     // the new response.
     UpdateTransactionPattern(PATTERN_NOT_COVERED);
     response_ = HttpResponseInfo();
     ResetNetworkTransaction();
     new_response_ = NULL;
     next_state_ = STATE_SEND_REQUEST;
     return OK;
@@ skipping 43 matching lines @@
     mode_ = WRITE;
   }
 
   next_state_ = STATE_OVERWRITE_CACHED_RESPONSE;
   return OK;
 }
 
 int HttpCache::Transaction::DoNetworkRead() {
   ReportNetworkActionStart();
   next_state_ = STATE_NETWORK_READ_COMPLETE;
-  return network_trans_->Read(read_buf_, io_buf_len_, io_callback_);
+  return network_trans_->Read(read_buf_.get(), io_buf_len_, io_callback_);
 }
 
 int HttpCache::Transaction::DoNetworkReadComplete(int result) {
   DCHECK(mode_ & WRITE || mode_ == NONE);
 
   ReportNetworkActionFinish();
 
   if (!cache_)
     return ERR_UNEXPECTED;
 
@@ skipping 235 matching lines @@
 
   return BeginCacheValidation();
 }
 
 // We received 304 or 206 and we want to update the cached response headers.
 int HttpCache::Transaction::DoUpdateCachedResponse() {
   next_state_ = STATE_UPDATE_CACHED_RESPONSE_COMPLETE;
   int rv = OK;
   // Update cached response based on headers in new_response.
   // TODO(wtc): should we update cached certificate (response_.ssl_info), too?
-  response_.headers->Update(*new_response_->headers);
+  response_.headers->Update(*new_response_->headers.get());
   response_.response_time = new_response_->response_time;
   response_.request_time = new_response_->request_time;
   response_.network_accessed = new_response_->network_accessed;
 
   if (response_.headers->HasHeaderValue("cache-control", "no-store")) {
     if (!entry_->doomed) {
       int ret = cache_->DoomEntry(cache_key_, NULL);
       DCHECK_EQ(OK, ret);
     }
   } else {
@@ skipping 42 matching lines @@
 }
 
 int HttpCache::Transaction::DoOverwriteCachedResponse() {
   if (mode_ & READ) {
     next_state_ = STATE_PARTIAL_HEADERS_RECEIVED;
     return OK;
   }
 
   // We change the value of Content-Length for partial content.
   if (handling_206_ && partial_.get())
-    partial_->FixContentLength(new_response_->headers);
+    partial_->FixContentLength(new_response_->headers.get());
 
   response_ = *new_response_;
 
   if (handling_206_ && !CanResume(false)) {
     // There is no point in storing this resource because it will never be used.
     DoneWritingToEntry(false);
     if (partial_.get())
-      partial_->FixResponseHeaders(response_.headers, true);
+      partial_->FixResponseHeaders(response_.headers.get(), true);
     next_state_ = STATE_PARTIAL_HEADERS_RECEIVED;
     return OK;
   }
 
   target_state_ = STATE_TRUNCATE_CACHED_DATA;
   next_state_ = truncated_ ? STATE_CACHE_WRITE_TRUNCATED_RESPONSE :
                              STATE_CACHE_WRITE_RESPONSE;
   return OK;
 }
 
@@ skipping 62 matching lines @@
 
   if (reading_) {
     if (network_trans_.get()) {
       next_state_ = STATE_NETWORK_READ;
     } else {
       next_state_ = STATE_CACHE_READ_DATA;
     }
   } else if (mode_ != NONE) {
     // We are about to return the headers for a byte-range request to the user,
     // so let's fix them.
-    partial_->FixResponseHeaders(response_.headers, true);
+    partial_->FixResponseHeaders(response_.headers.get(), true);
   }
   return OK;
 }
 
 int HttpCache::Transaction::DoCacheReadResponse() {
   DCHECK(entry_);
   next_state_ = STATE_CACHE_READ_RESPONSE_COMPLETE;
 
   io_buf_len_ = entry_->disk_entry->GetDataSize(kResponseInfoIndex);
   read_buf_ = new IOBuffer(io_buf_len_);
 
   net_log_.BeginEvent(NetLog::TYPE_HTTP_CACHE_READ_INFO);
   ReportCacheActionStart();
-  return ResetCacheIOStart(
-      entry_->disk_entry->ReadData(kResponseInfoIndex, 0, read_buf_,
-                                   io_buf_len_, io_callback_));
+  return ResetCacheIOStart(entry_->disk_entry->ReadData(
+      kResponseInfoIndex, 0, read_buf_.get(), io_buf_len_, io_callback_));
 }
 
 int HttpCache::Transaction::DoCacheReadResponseComplete(int result) {
   ReportCacheActionFinish();
   net_log_.EndEventWithNetErrorCode(NetLog::TYPE_HTTP_CACHE_READ_INFO, result);
   if (result != io_buf_len_ ||
       !HttpCache::ParseResponseInfo(read_buf_->data(), io_buf_len_,
                                     &response_, &truncated_)) {
     return OnCacheReadError(result, true);
   }
@@ skipping 67 matching lines @@
   // Balance the AddRef from WriteResponseInfoToEntry.
   if (result != io_buf_len_) {
     DLOG(ERROR) << "failed to write response info to cache";
     DoneWritingToEntry(false);
   }
   return OK;
 }
 
 int HttpCache::Transaction::DoCacheReadMetadata() {
   DCHECK(entry_);
-  DCHECK(!response_.metadata);
+  DCHECK(!response_.metadata.get());
   next_state_ = STATE_CACHE_READ_METADATA_COMPLETE;
 
   response_.metadata =
       new IOBufferWithSize(entry_->disk_entry->GetDataSize(kMetadataIndex));
 
   net_log_.BeginEvent(NetLog::TYPE_HTTP_CACHE_READ_INFO);
   ReportCacheActionStart();
   return ResetCacheIOStart(
-      entry_->disk_entry->ReadData(kMetadataIndex, 0, response_.metadata,
+      entry_->disk_entry->ReadData(kMetadataIndex,
+                                   0,
+                                   response_.metadata.get(),
                                    response_.metadata->size(),
                                    io_callback_));
 }
 
 int HttpCache::Transaction::DoCacheReadMetadataComplete(int result) {
   ReportCacheActionFinish();
   net_log_.EndEventWithNetErrorCode(NetLog::TYPE_HTTP_CACHE_READ_INFO, result);
   if (result != response_.metadata->size())
     return OnCacheReadError(result, false);
   return OK;
@@ skipping 16 matching lines @@
 }
 
 int HttpCache::Transaction::DoCacheReadData() {
   DCHECK(entry_);
   next_state_ = STATE_CACHE_READ_DATA_COMPLETE;
 
   if (net_log_.IsLoggingAllEvents())
     net_log_.BeginEvent(NetLog::TYPE_HTTP_CACHE_READ_DATA);
   ReportCacheActionStart();
   if (partial_.get()) {
-    return ResetCacheIOStart(
-        partial_->CacheRead(entry_->disk_entry, read_buf_, io_buf_len_,
-                            io_callback_));
+    return ResetCacheIOStart(partial_->CacheRead(
+        entry_->disk_entry, read_buf_.get(), io_buf_len_, io_callback_));
   }
 
-  return ResetCacheIOStart(
-      entry_->disk_entry->ReadData(kResponseContentIndex, read_offset_,
-                                   read_buf_, io_buf_len_, io_callback_));
+  return ResetCacheIOStart(entry_->disk_entry->ReadData(kResponseContentIndex,
+                                                        read_offset_,
+                                                        read_buf_.get(),
+                                                        io_buf_len_,
+                                                        io_callback_));
 }
 
 int HttpCache::Transaction::DoCacheReadDataComplete(int result) {
   ReportCacheActionFinish();
   if (net_log_.IsLoggingAllEvents()) {
     net_log_.EndEventWithNetErrorCode(NetLog::TYPE_HTTP_CACHE_READ_DATA,
                                       result);
   }
 
   if (!cache_)
@@ skipping 21 matching lines @@
 int HttpCache::Transaction::DoCacheWriteData(int num_bytes) {
   next_state_ = STATE_CACHE_WRITE_DATA_COMPLETE;
   write_len_ = num_bytes;
   if (entry_) {
     if (net_log_.IsLoggingAllEvents())
       net_log_.BeginEvent(NetLog::TYPE_HTTP_CACHE_WRITE_DATA);
     ReportCacheActionStart();
   }
 
   return ResetCacheIOStart(
-      AppendResponseDataToEntry(read_buf_, num_bytes, io_callback_));
+      AppendResponseDataToEntry(read_buf_.get(), num_bytes, io_callback_));
 }
 
 int HttpCache::Transaction::DoCacheWriteDataComplete(int result) {
   if (entry_) {
     ReportCacheActionFinish();
     if (net_log_.IsLoggingAllEvents()) {
       net_log_.EndEventWithNetErrorCode(NetLog::TYPE_HTTP_CACHE_WRITE_DATA,
                                         result);
     }
   }
@@ skipping 255 matching lines @@
     request_ = custom_request_.get();
   }
 
   return ValidateEntryHeadersAndContinue();
 }
 
 // This should only be called once per request.
 int HttpCache::Transaction::ValidateEntryHeadersAndContinue() {
   DCHECK(mode_ == READ_WRITE);
 
-  if (!partial_->UpdateFromStoredHeaders(response_.headers, entry_->disk_entry,
-                                         truncated_)) {
+  if (!partial_->UpdateFromStoredHeaders(
+          response_.headers.get(), entry_->disk_entry, truncated_)) {
     return DoRestartPartialRequest();
   }
 
   if (response_.headers->response_code() == 206)
     is_sparse_ = true;
 
   if (!partial_->IsRequestedRangeOK()) {
     // The stored data is fine, but the request may be invalid.
     invalid_range_ = true;
   }
@@ skipping 73 matching lines @@
 bool HttpCache::Transaction::RequiresValidation() {
   // TODO(darin): need to do more work here:
   //  - make sure we have a matching request method
   //  - watch out for cached responses that depend on authentication
 
   // In playback mode, nothing requires validation.
   if (cache_->mode() == net::HttpCache::PLAYBACK)
     return false;
 
   if (response_.vary_data.is_valid() &&
-      !response_.vary_data.MatchesRequest(*request_, *response_.headers)) {
+      !response_.vary_data.MatchesRequest(*request_,
+                                          *response_.headers.get())) {
     vary_mismatch_ = true;
     return true;
   }
 
   if (effective_load_flags_ & LOAD_PREFERRING_CACHE)
     return false;
 
   if (effective_load_flags_ & LOAD_VALIDATE_CACHE)
     return true;
 
   if (request_->method == "PUT" || request_->method == "DELETE")
     return true;
 
   if (response_.headers->RequiresValidation(
           response_.request_time, response_.response_time, Time::Now())) {
     return true;
   }
 
   return false;
 }
 
 bool HttpCache::Transaction::ConditionalizeRequest() {
-  DCHECK(response_.headers);
+  DCHECK(response_.headers.get());
 
   if (request_->method == "PUT" || request_->method == "DELETE")
     return false;
 
   // This only makes sense for cached 200 or 206 responses.
   if (response_.headers->response_code() != 200 &&
       response_.headers->response_code() != 206) {
     return false;
   }
 
@@ skipping 68 matching lines @@
 //
 // If the server is simply telling us that the resource has changed, we delete
 // the cached entry and restart the request as the caller intended (by returning
 // false from this method). However, we may not be able to do that at any point,
 // for instance if we already returned the headers to the user.
 //
 // WARNING: Whenever this code returns false, it has to make sure that the next
 // time it is called it will return true so that we don't keep retrying the
 // request.
 bool HttpCache::Transaction::ValidatePartialResponse() {
-  const HttpResponseHeaders* headers = new_response_->headers;
+  const HttpResponseHeaders* headers = new_response_->headers.get();
   int response_code = headers->response_code();
   bool partial_response = (response_code == 206);
   handling_206_ = false;
 
   if (!entry_ || request_->method != "GET")
     return true;
 
   if (invalid_range_) {
     // We gave up trying to match this request with the stored data. If the
     // server is ok with the request, delete the entry, otherwise just ignore
@@ skipping 89 matching lines @@
   else if (mode_ & READ && entry_)
     cache_->DoneReadingFromEntry(entry_, this);
 
   partial_.reset(NULL);
   entry_ = NULL;
   mode_ = NONE;
 }
 
 void HttpCache::Transaction::FailRangeRequest() {
   response_ = *new_response_;
-  partial_->FixResponseHeaders(response_.headers, false);
+  partial_->FixResponseHeaders(response_.headers.get(), false);
 }
 
 int HttpCache::Transaction::SetupEntryForRead() {
   if (network_trans_)
     ResetNetworkTransaction();
   if (partial_.get()) {
     if (truncated_ || is_sparse_ || !invalid_range_) {
       // We are going to return the saved response headers to the caller, so
       // we may need to adjust them first.
       next_state_ = STATE_PARTIAL_HEADERS_RECEIVED;
@@ skipping 70 matching lines @@
   bool skip_transient_headers = (cache_->mode() != RECORD);
 
   if (truncated)
     DCHECK_EQ(200, response_.headers->response_code());
 
   scoped_refptr<PickledIOBuffer> data(new PickledIOBuffer());
   response_.Persist(data->pickle(), skip_transient_headers, truncated);
   data->Done();
 
   io_buf_len_ = data->pickle()->size();
-  return ResetCacheIOStart(
-      entry_->disk_entry->WriteData(kResponseInfoIndex, 0, data,
-                                    io_buf_len_, io_callback_, true));
+  return ResetCacheIOStart(entry_->disk_entry->WriteData(
+      kResponseInfoIndex, 0, data.get(), io_buf_len_, io_callback_, true));
 }
 
 int HttpCache::Transaction::AppendResponseDataToEntry(
     IOBuffer* data, int data_len, const CompletionCallback& callback) {
   if (!entry_ || !data_len)
     return data_len;
 
   int current_size = entry_->disk_entry->GetDataSize(kResponseContentIndex);
   return WriteToEntry(kResponseContentIndex, current_size, data, data_len,
                       callback);
@@ skipping 300 matching lines @@
 void HttpCache::Transaction::ResetNetworkTransaction() {
   DCHECK(!old_network_trans_load_timing_);
   DCHECK(network_trans_);
   LoadTimingInfo load_timing;
   if (network_trans_->GetLoadTimingInfo(&load_timing))
     old_network_trans_load_timing_.reset(new LoadTimingInfo(load_timing));
   network_trans_.reset();
 }
 
 }  // namespace net