Add checks for entry_. From coverity CID=8237

net/http/http_cache_transaction.cc

 // Copyright (c) 2011 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 1012 matching lines @@
   if (mode_ == UPDATE) {
     DCHECK(!server_responded_206_);
     // We got a "not modified" response and already updated the corresponding
     // cache entry above.
     //
     // By closing the cached entry now, we make sure that the 304 rather than
     // the cached 200 response, is what will be returned to the user.
     DoneWritingToEntry(true);
   } else if (entry_ && !server_responded_206_) {
     DCHECK_EQ(READ_WRITE, mode_);
-    if (!partial_.get() || partial_->IsLastRange()) {
+    if (entry_ && !partial_.get() || partial_->IsLastRange()) {

[rvargas (doing something else), 2011/06/23 19:00:27]

entry_ is already considered at line 1031

[Greg Billock, 2011/06/23 20:13:25]

Done.

       cache_->ConvertWriterToReader(entry_);
       mode_ = READ;
     }
     // We no longer need the network transaction, so destroy it.
     final_upload_progress_ = network_trans_->GetUploadProgress();
     network_trans_.reset();
   } else if (entry_ && server_responded_206_ && truncated_ &&
              partial_->initial_validation()) {
     // We just finished the validation of a truncated entry, and the server
     // is willing to resume the operation. Now we go back and start serving
@@ skipping 462 matching lines @@
   if ((partial_.get() && !partial_->IsCurrentRangeCached()) || invalid_range_)
     skip_validation = false;
 
   if (skip_validation) {
     if (partial_.get()) {
       // 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;
       return OK;
     }
-    cache_->ConvertWriterToReader(entry_);
-    mode_ = READ;
+    if (entry_) {

[rvargas (doing something else), 2011/06/23 19:00:27]

The state machine guarantees that there should be an entry at this point.

Feel free to remove the test at line 1521.

[Greg Billock, 2011/06/23 20:13:25]

Done. I'll mark this intentional in coverity.

+      cache_->ConvertWriterToReader(entry_);
+      mode_ = READ;
+    }
 
     if (entry_ && entry_->disk_entry->GetDataSize(kMetadataIndex))
       next_state_ = STATE_CACHE_READ_METADATA;
   } else {
     // Make the network request conditional, to see if we may reuse our cached
     // response.  If we cannot do so, then we just resort to a normal fetch.
     // Our mode remains READ_WRITE for a conditional request.  We'll switch to
     // either READ or WRITE mode once we hear back from the server.
     if (!ConditionalizeRequest()) {
       DCHECK(!partial_.get());
@@ skipping 488 matching lines @@
     return false;
 
   return true;
 }
 
 void HttpCache::Transaction::OnIOComplete(int result) {
   DoLoop(result);
 }
 
 }  // namespace net