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

webkit/appcache/appcache_update_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/appcache/appcache_update_job.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/message_loop.h"
@@ skipping 90 matching lines @@
       request_(job->service_->request_context()->CreateRequest(url, this)) {
 }
 
 AppCacheUpdateJob::URLFetcher::~URLFetcher() {
 }
 
 void AppCacheUpdateJob::URLFetcher::Start() {
   request_->set_first_party_for_cookies(job_->manifest_url_);
   request_->set_load_flags(request_->load_flags() |
                            net::LOAD_DISABLE_INTERCEPT);
-  if (existing_response_headers_)
-    AddConditionalHeaders(existing_response_headers_);
+  if (existing_response_headers_.get())
+    AddConditionalHeaders(existing_response_headers_.get());
   request_->Start();
 }
 
 void AppCacheUpdateJob::URLFetcher::OnReceivedRedirect(
     net::URLRequest* request, const GURL& new_url,  bool* defer_redirect) {
   DCHECK(request_ == request);
   // Redirect is not allowed by the update process.
   request->Cancel();
   OnResponseCompleted();
 }
@@ skipping 22 matching lines @@
     }
 
     // Write response info to storage for URL fetches. Wait for async write
     // completion before reading any response data.
     if (fetch_type_ == URL_FETCH || fetch_type_ == MASTER_ENTRY_FETCH) {
       response_writer_.reset(job_->CreateResponseWriter());
       scoped_refptr<HttpResponseInfoIOBuffer> io_buffer(
           new HttpResponseInfoIOBuffer(
               new net::HttpResponseInfo(request->response_info())));
       response_writer_->WriteInfo(
-          io_buffer,
+          io_buffer.get(),
           base::Bind(&URLFetcher::OnWriteComplete, base::Unretained(this)));
     } else {
       ReadResponseData();
     }
   } else {
     OnResponseCompleted();
   }
 }
 
 void AppCacheUpdateJob::URLFetcher::OnReadCompleted(
     net::URLRequest* request, int bytes_read) {
   DCHECK(request_ == request);
   bool data_consumed = true;
   if (request->status().is_success() && bytes_read > 0) {
     data_consumed = ConsumeResponseData(bytes_read);
     if (data_consumed) {
       bytes_read = 0;
-      while (request->Read(buffer_, kBufferSize, &bytes_read)) {
+      while (request->Read(buffer_.get(), kBufferSize, &bytes_read)) {
         if (bytes_read > 0) {
           data_consumed = ConsumeResponseData(bytes_read);
           if (!data_consumed)
             break;  // wait for async data processing, then read more
         } else {
           break;
         }
       }
     }
   }
@@ skipping 34 matching lines @@
     return;
   }
   ReadResponseData();
 }
 
 void AppCacheUpdateJob::URLFetcher::ReadResponseData() {
   InternalUpdateState state = job_->internal_state_;
   if (state == CACHE_FAILURE || state == CANCELLED || state == COMPLETED)
     return;
   int bytes_read = 0;
-  request_->Read(buffer_, kBufferSize, &bytes_read);
+  request_->Read(buffer_.get(), kBufferSize, &bytes_read);
   OnReadCompleted(request_.get(), bytes_read);
 }
 
 // Returns false if response data is processed asynchronously, in which
 // case ReadResponseData will be invoked when it is safe to continue
 // reading more response data from the request.
 bool AppCacheUpdateJob::URLFetcher::ConsumeResponseData(int bytes_read) {
   DCHECK_GT(bytes_read, 0);
   switch (fetch_type_) {
     case MANIFEST_FETCH:
     case MANIFEST_REFETCH:
       manifest_data_.append(buffer_->data(), bytes_read);
       break;
     case URL_FETCH:
     case MASTER_ENTRY_FETCH:
       DCHECK(response_writer_.get());
       response_writer_->WriteData(
-          buffer_, bytes_read,
+          buffer_.get(),
+          bytes_read,
           base::Bind(&URLFetcher::OnWriteComplete, base::Unretained(this)));
       return false;  // wait for async write completion to continue reading
     default:
       NOTREACHED();
   }
   return true;
 }
 
 void AppCacheUpdateJob::URLFetcher::OnResponseCompleted() {
   // Retry for 503s where retry-after is 0.
@@ skipping 46 matching lines @@
       manifest_fetcher_(NULL),
       stored_state_(UNSTORED) {
 }
 
 AppCacheUpdateJob::~AppCacheUpdateJob() {
   if (internal_state_ != COMPLETED)
     Cancel();
 
   DCHECK(!manifest_fetcher_);
   DCHECK(pending_url_fetches_.empty());
-  DCHECK(!inprogress_cache_);
+  DCHECK(!inprogress_cache_.get());
   DCHECK(pending_master_entries_.empty());
   DCHECK(master_entry_fetches_.empty());
 
   if (group_)
     group_->SetUpdateStatus(AppCacheGroup::IDLE);
 }
 
 void AppCacheUpdateJob::StartUpdate(AppCacheHost* host,
                                     const GURL& new_master_resource) {
   DCHECK(group_->update_job() == this);
@@ skipping 93 matching lines @@
       // Asynchronously load response info for manifest from newest cache.
       service_->storage()->LoadResponseInfo(manifest_url_, group_->group_id(),
                                             entry->response_id(), this);
     } else {
       manifest_fetcher_->Start();
     }
   } else {
     DCHECK(internal_state_ == REFETCH_MANIFEST);
     DCHECK(manifest_response_info_.get());
     manifest_fetcher_->set_existing_response_headers(
-        manifest_response_info_->headers);
+        manifest_response_info_->headers.get());
     manifest_fetcher_->Start();
   }
 }
 
 
 void AppCacheUpdateJob::HandleManifestFetchCompleted(
     URLFetcher* fetcher) {
   DCHECK_EQ(internal_state_, FETCH_MANIFEST);
   DCHECK_EQ(manifest_fetcher_, fetcher);
   manifest_fetcher_ = NULL;
@@ skipping 73 matching lines @@
                                    service_->storage()->NewCacheId());
   BuildUrlFileList(manifest);
   inprogress_cache_->InitializeWithManifest(&manifest);
 
   // Associate all pending master hosts with the newly created cache.
   for (PendingMasters::iterator it = pending_master_entries_.begin();
        it != pending_master_entries_.end(); ++it) {
     PendingHosts& hosts = it->second;
     for (PendingHosts::iterator host_it = hosts.begin();
          host_it != hosts.end(); ++host_it) {
-      (*host_it)->AssociateIncompleteCache(inprogress_cache_, manifest_url_);
+      (*host_it)
+          ->AssociateIncompleteCache(inprogress_cache_.get(), manifest_url_);
     }
   }
 
   group_->SetUpdateStatus(AppCacheGroup::DOWNLOADING);
   NotifyAllAssociatedHosts(DOWNLOADING_EVENT);
   FetchUrls();
   FetchMasterEntries();
   MaybeCompleteUpdate();  // if not done, continues when async fetches complete
 }
 
@@ skipping 82 matching lines @@
   int response_code = request->status().is_success()
       ? request->GetResponseCode() : -1;
 
   PendingMasters::iterator found = pending_master_entries_.find(url);
   DCHECK(found != pending_master_entries_.end());
   PendingHosts& hosts = found->second;
 
   // Section 6.9.4. No update case: step 7.3, else step 22.
   if (response_code / 100 == 2) {
     // Add fetched master entry to the appropriate cache.
-    AppCache* cache = inprogress_cache_ ? inprogress_cache_.get() :
-        group_->newest_complete_cache();
+    AppCache* cache = inprogress_cache_.get() ? inprogress_cache_.get()
+                                              : group_->newest_complete_cache();
     DCHECK(fetcher->response_writer());
     AppCacheEntry master_entry(AppCacheEntry::MASTER,
                                fetcher->response_writer()->response_id(),
                                fetcher->response_writer()->amount_written());
     if (cache->AddOrModifyEntry(url, master_entry))
       added_master_entries_.push_back(url);
     else
       duplicate_response_ids_.push_back(master_entry.response_id());
 
     // In no-update case, associate host with the newest cache.
-    if (!inprogress_cache_) {
+    if (!inprogress_cache_.get()) {
       // TODO(michaeln): defer until the updated cache has been stored
       DCHECK(cache == group_->newest_complete_cache());
       for (PendingHosts::iterator host_it = hosts.begin();
            host_it != hosts.end(); ++host_it) {
         (*host_it)->AssociateCompleteCache(cache);
       }
     }
   } else {
     HostNotifier host_notifier;
     for (PendingHosts::iterator host_it = hosts.begin();
          host_it != hosts.end(); ++host_it) {
       AppCacheHost* host = *host_it;
       host_notifier.AddHost(host);
 
       // In downloading case, disassociate host from inprogress cache.
-      if (inprogress_cache_)
+      if (inprogress_cache_.get())
         host->AssociateNoCache(GURL());
 
       host->RemoveObserver(this);
     }
     hosts.clear();
 
     const char* kFormatString = "Master entry fetch failed (%d) %s";
     const std::string message = base::StringPrintf(kFormatString,
         response_code, request->url().spec().c_str());
     host_notifier.SendErrorNotifications(message);
 
     // In downloading case, update result is different if all master entries
     // failed vs. only some failing.
-    if (inprogress_cache_) {
+    if (inprogress_cache_.get()) {
       // Only count successful downloads to know if all master entries failed.
       pending_master_entries_.erase(found);
       --master_entries_completed_;
 
       // Section 6.9.4, step 22.3.
       if (update_type_ == CACHE_ATTEMPT && pending_master_entries_.empty()) {
         HandleCacheFailure(message);
         return;
       }
     }
@@ skipping 18 matching lines @@
     // 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(CreateResponseWriter());
       scoped_refptr<HttpResponseInfoIOBuffer> io_buffer(
           new HttpResponseInfoIOBuffer(manifest_response_info_.release()));
       manifest_response_writer_->WriteInfo(
-          io_buffer,
+          io_buffer.get(),
           base::Bind(&AppCacheUpdateJob::OnManifestInfoWriteComplete,
                      base::Unretained(this)));
     }
   } else {
     VLOG(1) << "Request status: " << request->status().status()
             << " error: " << request->status().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_));
     manifest_response_writer_->WriteData(
-        io_buffer, manifest_data_.length(),
+        io_buffer.get(),
+        manifest_data_.length(),
         base::Bind(&AppCacheUpdateJob::OnManifestDataWriteComplete,
                    base::Unretained(this)));
   } else {
     HandleCacheFailure("Failed to write the manifest headers to storage");
   }
 }
 
 void AppCacheUpdateJob::OnManifestDataWriteComplete(int result) {
   if (result > 0) {
     AppCacheEntry entry(AppCacheEntry::MANIFEST,
         manifest_response_writer_->response_id(),
         manifest_response_writer_->amount_written());
     if (!inprogress_cache_->AddOrModifyEntry(manifest_url_, entry))
       duplicate_response_ids_.push_back(entry.response_id());
     StoreGroupAndCache();
   } else {
     HandleCacheFailure("Failed to write the manifest data to storage");
   }
 }
 
 void AppCacheUpdateJob::StoreGroupAndCache() {
   DCHECK(stored_state_ == UNSTORED);
   stored_state_ = STORING;
   scoped_refptr<AppCache> newest_cache;
-  if (inprogress_cache_)
+  if (inprogress_cache_.get())
     newest_cache.swap(inprogress_cache_);
   else
     newest_cache = group_->newest_complete_cache();
   newest_cache->set_update_time(base::Time::Now());
 
   // TODO(michaeln): dcheck is fishing for clues to crbug/95101
   DCHECK_EQ(manifest_url_, group_->manifest_url());
-  service_->storage()->StoreGroupAndNewestCache(group_, newest_cache,
-                                                this);  // async
+  service_->storage()
+      ->StoreGroupAndNewestCache(group_, newest_cache.get(), this);  // async
 }
 
 void AppCacheUpdateJob::OnGroupAndNewestCacheStored(AppCacheGroup* group,
                                                     AppCache* newest_cache,
                                                     bool success,
                                                     bool would_exceed_quota) {
   DCHECK(stored_state_ == STORING);
   if (success) {
     stored_state_ = STORED;
     MaybeCompleteUpdate();  // will definitely complete
@@ skipping 38 matching lines @@
   HostNotifier host_notifier;
   AddAllAssociatedHostsToNotifier(&host_notifier);
   host_notifier.SendErrorNotifications(error_message);
 }
 
 void AppCacheUpdateJob::AddAllAssociatedHostsToNotifier(
     HostNotifier* host_notifier) {
   // Collect hosts so we only send one notification per frontend.
   // A host can only be associated with a single cache so no need to worry
   // about duplicate hosts being added to the notifier.
-  if (inprogress_cache_) {
+  if (inprogress_cache_.get()) {
     DCHECK(internal_state_ == DOWNLOADING || internal_state_ == CACHE_FAILURE);
     host_notifier->AddHosts(inprogress_cache_->associated_hosts());
   }
 
   AppCacheGroup::Caches old_caches = group_->old_caches();
   for (AppCacheGroup::Caches::const_iterator it = old_caches.begin();
        it != old_caches.end(); ++it) {
     host_notifier->AddHosts((*it)->associated_hosts());
   }
 
@@ skipping 26 matching lines @@
     return;
   }
 
   // Load manifest data from storage to compare against fetched manifest.
   manifest_response_reader_.reset(
       service_->storage()->CreateResponseReader(manifest_url_,
                                                 group_->group_id(),
                                                 entry->response_id()));
   read_manifest_buffer_ = new net::IOBuffer(kBufferSize);
   manifest_response_reader_->ReadData(
-      read_manifest_buffer_, kBufferSize,
+      read_manifest_buffer_.get(),
+      kBufferSize,
       base::Bind(&AppCacheUpdateJob::OnManifestDataReadComplete,
                  base::Unretained(this)));  // async read
 }
 
 void AppCacheUpdateJob::OnManifestDataReadComplete(int result) {
   if (result > 0) {
     loaded_manifest_data_.append(read_manifest_buffer_->data(), result);
     manifest_response_reader_->ReadData(
-        read_manifest_buffer_, kBufferSize,
+        read_manifest_buffer_.get(),
+        kBufferSize,
         base::Bind(&AppCacheUpdateJob::OnManifestDataReadComplete,
                    base::Unretained(this)));  // read more
   } else {
     read_manifest_buffer_ = NULL;
     manifest_response_reader_.reset();
     ContinueHandleManifestFetchCompleted(
         result < 0 || manifest_data_ != loaded_manifest_data_);
   }
 }
 
@@ skipping 63 matching lines @@
       ++url_fetches_completed_;
     } else if (AlreadyFetchedEntry(url_to_fetch.url, entry.types())) {
       NotifyAllProgress(url_to_fetch.url);
       ++url_fetches_completed_;  // saved a URL request
     } else if (!url_to_fetch.storage_checked &&
                MaybeLoadFromNewestCache(url_to_fetch.url, entry)) {
       // Continues asynchronously after data is loaded from newest cache.
     } else {
       URLFetcher* fetcher = new URLFetcher(
           url_to_fetch.url, URLFetcher::URL_FETCH, this);
-      if (url_to_fetch.existing_response_info) {
+      if (url_to_fetch.existing_response_info.get()) {
         DCHECK(group_->newest_complete_cache());
         AppCacheEntry* existing_entry =
             group_->newest_complete_cache()->GetEntry(url_to_fetch.url);
         DCHECK(existing_entry);
         DCHECK(existing_entry->response_id() ==
                url_to_fetch.existing_response_info->response_id());
         fetcher->set_existing_response_headers(
-            url_to_fetch.existing_response_info->http_response_info()->headers);
+            url_to_fetch.existing_response_info->http_response_info()->headers
+                .get());
         fetcher->set_existing_entry(*existing_entry);
       }
       fetcher->Start();
       pending_url_fetches_.insert(
           PendingUrlFetches::value_type(url_to_fetch.url, fetcher));
     }
   }
 }
 
 void AppCacheUpdateJob::CancelAllUrlFetches() {
@@ skipping 17 matching lines @@
   if (entry.IsExplicit() || entry.IsFallback() || entry.IsIntercept())
     return false;
 
   // TODO(jennb): decide if entry should be skipped to expire it from cache
   return false;
 }
 
 bool AppCacheUpdateJob::AlreadyFetchedEntry(const GURL& url,
                                             int entry_type) {
   DCHECK(internal_state_ == DOWNLOADING || internal_state_ == NO_UPDATE);
-  AppCacheEntry* existing = inprogress_cache_ ?
-      inprogress_cache_->GetEntry(url) :
-      group_->newest_complete_cache()->GetEntry(url);
+  AppCacheEntry* existing =
+      inprogress_cache_.get() ? inprogress_cache_->GetEntry(url)
+                              : group_->newest_complete_cache()->GetEntry(url);
   if (existing) {
     existing->add_types(entry_type);
     return true;
   }
   return false;
 }
 
 void AppCacheUpdateJob::AddMasterEntryToFetchList(AppCacheHost* host,
                                                   const GURL& url,
                                                   bool is_new) {
   DCHECK(!IsTerminating());
 
   if (internal_state_ == DOWNLOADING || internal_state_ == NO_UPDATE) {
     AppCache* cache;
-    if (inprogress_cache_) {
+    if (inprogress_cache_.get()) {
       // always associate
-      host->AssociateIncompleteCache(inprogress_cache_, manifest_url_);
+      host->AssociateIncompleteCache(inprogress_cache_.get(), manifest_url_);
       cache = inprogress_cache_.get();
     } else {
       cache = group_->newest_complete_cache();
     }
 
     // Update existing entry if it has already been fetched.
     AppCacheEntry* entry = cache->GetEntry(url);
     if (entry) {
       entry->add_types(AppCacheEntry::MASTER);
-      if (internal_state_ == NO_UPDATE && !inprogress_cache_) {
+      if (internal_state_ == NO_UPDATE && !inprogress_cache_.get()) {
         // only associate if have entry
         host->AssociateCompleteCache(cache);
       }
       if (is_new)
         ++master_entries_completed_;  // pretend fetching completed
       return;
     }
   }
 
   // Add to fetch list if not already fetching.
@@ skipping 102 matching lines @@
 }
 
 void AppCacheUpdateJob::OnResponseInfoLoaded(
     AppCacheResponseInfo* response_info, int64 response_id) {
   const net::HttpResponseInfo* http_info = response_info ?
       response_info->http_response_info() : NULL;
 
   // Needed response info for a manifest fetch request.
   if (internal_state_ == FETCH_MANIFEST) {
     if (http_info)
-      manifest_fetcher_->set_existing_response_headers(http_info->headers);
+      manifest_fetcher_->set_existing_response_headers(
+          http_info->headers.get());
     manifest_fetcher_->Start();
     return;
   }
 
   LoadingResponses::iterator found = loading_responses_.find(response_id);
   DCHECK(found != loading_responses_.end());
   const GURL& url = found->second;
 
   if (!http_info) {
     LoadFromNewestCacheFailed(url, NULL);  // no response found
   } else {
     // Check if response can be re-used according to HTTP caching semantics.
     // Responses with a "vary" header get treated as expired.
     const std::string name = "vary";
     std::string value;
     void* iter = NULL;
-    if (!http_info->headers ||
+    if (!http_info->headers.get() ||
         http_info->headers->RequiresValidation(http_info->request_time,
                                                http_info->response_time,
                                                base::Time::Now()) ||
         http_info->headers->EnumerateHeader(&iter, name, &value)) {
       LoadFromNewestCacheFailed(url, response_info);
     } else {
       DCHECK(group_->newest_complete_cache());
       AppCacheEntry* copy_me = group_->newest_complete_cache()->GetEntry(url);
       DCHECK(copy_me);
       DCHECK(copy_me->response_id() == response_id);
@@ skipping 123 matching lines @@
       (*host_it)->RemoveObserver(this);
     }
   }
 
   pending_master_entries_.clear();
 }
 
 void AppCacheUpdateJob::DiscardInprogressCache() {
   service_->storage()->DoomResponses(manifest_url_, stored_response_ids_);
 
-  if (!inprogress_cache_) {
+  if (!inprogress_cache_.get()) {
     // We have to undo the changes we made, if any, to the existing cache.
     for (std::vector<GURL>::iterator iter = added_master_entries_.begin();
          iter != added_master_entries_.end(); ++iter) {
       DCHECK(group_->newest_complete_cache());
       group_->newest_complete_cache()->RemoveEntry(*iter);
     }
     return;
   }
 
   AppCache::AppCacheHosts& hosts = inprogress_cache_->associated_hosts();
@@ skipping 14 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;
 
   base::MessageLoop::current()->DeleteSoon(FROM_HERE, this);
 }
 
 }  // namespace appcache