Fix DCHECK in debug build when navigating to an unknown chrome://theme/ URL.

content/browser/webui/url_data_manager_backend.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 "content/browser/webui/url_data_manager_backend.h"
 
 #include <set>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 130 matching lines @@
   int ReadRawData(net::IOBuffer* buf, int buf_size) override;
   bool GetMimeType(std::string* mime_type) const override;
   int GetResponseCode() const override;
   void GetResponseInfo(net::HttpResponseInfo* info) override;
   std::unique_ptr<net::Filter> SetupFilter() const override;
 
   // Used to notify that the requested data's |mime_type| is ready.
   void MimeTypeAvailable(const std::string& mime_type);
 
   // Called by ChromeURLDataManager to notify us that the data blob is ready
-  // for us.
+  // for us.  |bytes| may be null, indicating an error.
   void DataAvailable(base::RefCountedMemory* bytes);
 
   // Returns a weak pointer to the job.
   base::WeakPtr<URLRequestChromeJob> AsWeakPtr();
 
   void set_mime_type(const std::string& mime_type) {
     mime_type_ = mime_type;
   }
 
   void set_allow_caching(bool allow_caching) {
@@ skipping 63 matching lines @@
   // https://crbug.com/616641.
   static void DelayStartForDevTools(
       const base::WeakPtr<URLRequestChromeJob>& job);
 
   // Post a task to copy |data_| to |buf_| on a worker thread, to avoid browser
   // jank. (|data_| might be mem-mapped, so a memcpy can trigger file ops).
   int PostReadTask(scoped_refptr<net::IOBuffer> buf, int buf_size);
 
   // The actual data we're serving.  NULL until it's been fetched.
   scoped_refptr<base::RefCountedMemory> data_;
+
   // The current offset into the data that we're handing off to our
   // callers via the Read interfaces.
   int data_offset_;
 
+  // When DataAvailable() is called with a null argument, indicating an error,
+  // this is set accordingly to a code for ReadRawData() to return.
+  net::Error data_available_status_;
+
   // For async reads, we keep around a pointer to the buffer that
   // we're reading into.
   scoped_refptr<net::IOBuffer> pending_buf_;
   int pending_buf_size_;
   std::string mime_type_;
 
   // If true, set a header in the response to prevent it from being cached.
   bool allow_caching_;
 
   // If true, set the Content Security Policy (CSP) header.
@@ skipping 30 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(URLRequestChromeJob);
 };
 
 URLRequestChromeJob::URLRequestChromeJob(net::URLRequest* request,
                                          net::NetworkDelegate* network_delegate,
                                          URLDataManagerBackend* backend,
                                          bool is_incognito)
     : net::URLRequestJob(request, network_delegate),
       data_offset_(0),
+      data_available_status_(net::OK),
       pending_buf_size_(0),
       allow_caching_(true),
       add_content_security_policy_(true),
       deny_xframe_options_(true),
       send_content_type_header_(false),
       is_incognito_(is_incognito),
       is_gzipped_(false),
       backend_(backend),
       weak_factory_(this) {
   DCHECK(backend);
@@ skipping 93 matching lines @@
 
 void URLRequestChromeJob::MimeTypeAvailable(const std::string& mime_type) {
   set_mime_type(mime_type);
   NotifyHeadersComplete();
 }
 
 void URLRequestChromeJob::DataAvailable(base::RefCountedMemory* bytes) {
   TRACE_EVENT_ASYNC_END0("browser", "DataManager:Request", this);
   DCHECK(!data_);
 
-  // A passed-in nullptr signals an error.
-  if (!bytes) {
-    ReadRawDataComplete(net::ERR_FAILED);
-    return;
-  }
-
   // All further requests will be satisfied from the passed-in data.
   data_ = bytes;
+  if (!bytes)
+    data_available_status_ = net::ERR_FAILED;
 
   if (pending_buf_) {
-    int result = PostReadTask(pending_buf_, pending_buf_size_);
+    // The request has already been marked async.
+    int result = bytes ? PostReadTask(pending_buf_, pending_buf_size_)
+                       : data_available_status_;
     pending_buf_ = nullptr;
     if (result != net::ERR_IO_PENDING)
       ReadRawDataComplete(result);
   }
 }
 
 base::WeakPtr<URLRequestChromeJob> URLRequestChromeJob::AsWeakPtr() {
   return weak_factory_.GetWeakPtr();
 }
 
 int URLRequestChromeJob::ReadRawData(net::IOBuffer* buf, int buf_size) {
   DCHECK(!pending_buf_.get());
 
-  // If data isn't available yet, mark this as asynchronous.
-  if (!data_.get()) {
-    pending_buf_ = buf;
-    pending_buf_size_ = buf_size;
-    return net::ERR_IO_PENDING;
-  }
+  // Handle the cases when DataAvailable() has already been called.
+  if (data_available_status_ != net::OK)
+    return data_available_status_;
+  if (data_)
+    return PostReadTask(buf, buf_size);
 
-  return PostReadTask(buf, buf_size);
+  // DataAvailable() has not been called yet.  Mark the request as async.
+  pending_buf_ = buf;
+  pending_buf_size_ = buf_size;
+  return net::ERR_IO_PENDING;
 }
 
 int URLRequestChromeJob::PostReadTask(scoped_refptr<net::IOBuffer> buf,
                                       int buf_size) {
   DCHECK(buf);
   DCHECK(data_);
   CHECK(buf->data());
 
   int remaining = data_->size() - data_offset_;
   if (buf_size > remaining)
@@ skipping 391 matching lines @@
 
 }  // namespace
 
 net::URLRequestJobFactory::ProtocolHandler* CreateDevToolsProtocolHandler(
     ResourceContext* resource_context,
     bool is_incognito) {
   return new DevToolsJobFactory(resource_context, is_incognito);
 }
 
 }  // namespace content