Convert implicit scoped_refptr constructor calls to explicit ones, part 1

webkit/appcache/appcache_update_job.cc

 // Copyright (c) 2010 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/appcache/appcache_update_job.h"
 
 #include "base/compiler_specific.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
@@ skipping 335 matching lines @@
       (request->GetResponseCode() / 100) == 2) {
     // Write response info to storage for URL fetches. Wait for async write
     // completion before reading any response data.
     UpdateJobInfo* info = GetUpdateJobInfo(request);
     if (info->type_ == UpdateJobInfo::URL_FETCH ||
         info->type_ == UpdateJobInfo::MASTER_ENTRY_FETCH) {
       info->SetUpResponseWriter(
           service_->storage()->CreateResponseWriter(manifest_url_),
           this, request);
       stored_response_ids_.push_back(info->response_writer_->response_id());
-      scoped_refptr<HttpResponseInfoIOBuffer> io_buffer =
+      scoped_refptr<HttpResponseInfoIOBuffer> io_buffer(
           new HttpResponseInfoIOBuffer(
-              new net::HttpResponseInfo(request->response_info()));
+              new net::HttpResponseInfo(request->response_info())));
       info->response_writer_->WriteInfo(io_buffer, &info->write_callback_);
     } else {
       ReadResponseData(request);
     }
   } else {
     OnResponseCompleted(request);
   }
 }
 
 void AppCacheUpdateJob::ReadResponseData(URLRequest* request) {
@@ skipping 406 matching lines @@
     // Only need to store response in storage if manifest is not already
     // an entry in the cache.
     AppCacheEntry* entry = inprogress_cache_->GetEntry(manifest_url_);
     if (entry) {
       entry->add_types(AppCacheEntry::MANIFEST);
       StoreGroupAndCache();
     } else {
       manifest_response_writer_.reset(
           service_->storage()->CreateResponseWriter(manifest_url_));
       stored_response_ids_.push_back(manifest_response_writer_->response_id());
-      scoped_refptr<HttpResponseInfoIOBuffer> io_buffer =
-          new HttpResponseInfoIOBuffer(manifest_response_info_.release());
+      scoped_refptr<HttpResponseInfoIOBuffer> io_buffer(
+          new HttpResponseInfoIOBuffer(manifest_response_info_.release()));
       manifest_response_writer_->WriteInfo(io_buffer,
                                            &manifest_info_write_callback_);
     }
   } else {
     VLOG(1) << "Request status: " << request->status().status()
             << " os_error: " << request->status().os_error()
             << " response code: " << response_code;
     ScheduleUpdateRetry(kRerunDelayMs);
     HandleCacheFailure("Manifest changed during update, scheduling retry");
   }
 }
 
 void AppCacheUpdateJob::OnManifestInfoWriteComplete(int result) {
   if (result > 0) {
-    scoped_refptr<net::StringIOBuffer> io_buffer =
-        new net::StringIOBuffer(manifest_data_);
+    scoped_refptr<net::StringIOBuffer> io_buffer(
+        new net::StringIOBuffer(manifest_data_));
     manifest_response_writer_->WriteData(io_buffer, manifest_data_.length(),
                                          &manifest_data_write_callback_);
   } else {
     HandleCacheFailure("Failed to write the manifest headers to storage");
   }
 }
 
 void AppCacheUpdateJob::OnManifestDataWriteComplete(int result) {
   if (result > 0) {
     AppCacheEntry entry(AppCacheEntry::MANIFEST,
@@ skipping 592 matching lines @@
 
   // Break the connection with the group so the group cannot call delete
   // on this object after we've posted a task to delete ourselves.
   group_->SetUpdateStatus(AppCacheGroup::IDLE);
   group_ = NULL;
 
   MessageLoop::current()->DeleteSoon(FROM_HERE, this);
 }
 
 }  // namespace appcache