Initialize a member in URLRequestChromeJob.

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"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/debug/alias.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
@@ skipping 32 matching lines @@
 #include "url/url_util.h"
 
 namespace content {
 
 namespace {
 
 const char kChromeURLContentSecurityPolicyHeaderBase[] =
     "Content-Security-Policy: ";
 
 const char kChromeURLXFrameOptionsHeader[] = "X-Frame-Options: DENY";
-static const char kNetworkErrorKey[] = "netError";
+const char kNetworkErrorKey[] = "netError";
 
 bool SchemeIsInSchemes(const std::string& scheme,
                        const std::vector<std::string>& schemes) {
   return std::find(schemes.begin(), schemes.end(), scheme) != schemes.end();
 }
 
 // Returns whether |url| passes some sanity checks and is a valid GURL.
 bool CheckURLIsValid(const GURL& url) {
   std::vector<std::string> additional_schemes;
   DCHECK(url.SchemeIs(kChromeDevToolsScheme) || url.SchemeIs(kChromeUIScheme) ||
@@ skipping 180 matching lines @@
   std::string access_control_allow_origin_;
 
   // True when job is generated from an incognito profile.
   const bool is_incognito_;
 
   // True when gzip encoding should be used. NOTE: this requires the original
   // resources in resources.pak use compress="gzip".
   bool is_gzipped_;
 
   // The backend is owned by net::URLRequestContext and always outlives us.
-  URLDataManagerBackend* backend_;
+  URLDataManagerBackend* const backend_;
 
   base::WeakPtrFactory<URLRequestChromeJob> weak_factory_;
 
   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),
       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);
 }
 
 URLRequestChromeJob::~URLRequestChromeJob() {
   CHECK(!backend_->HasPendingJob(this));
 }
 
 void URLRequestChromeJob::Start() {
@@ skipping 89 matching lines @@
   NotifyHeadersComplete();
 }
 
 void URLRequestChromeJob::DataAvailable(base::RefCountedMemory* bytes) {
   TRACE_EVENT_ASYNC_END0("browser", "DataManager:Request", this);
   if (bytes) {
     data_ = bytes;
     if (pending_buf_.get()) {
       CHECK(pending_buf_->data());
       int result = CompleteRead(pending_buf_.get(), pending_buf_size_);
-      pending_buf_ = NULL;
+      pending_buf_ = nullptr;
       ReadRawDataComplete(result);
     }
   } else {
     // The request failed.
     ReadRawDataComplete(net::ERR_FAILED);
   }
 }
 
 base::WeakPtr<URLRequestChromeJob> URLRequestChromeJob::AsWeakPtr() {
   return weak_factory_.GetWeakPtr();
@@ skipping 147 matching lines @@
         request, network_delegate,
         GetURLDataManagerForResourceContext(resource_context_), is_incognito_);
   }
 
   bool IsSafeRedirectTarget(const GURL& location) const override {
     return false;
   }
 
  private:
   // These members are owned by ProfileIOData, which owns this ProtocolHandler.
-  content::ResourceContext* const resource_context_;
+  ResourceContext* const resource_context_;
 
   // True when generated from an incognito profile.
   const bool is_incognito_;
   ChromeBlobStorageContext* blob_storage_context_;
 
   DISALLOW_COPY_AND_ASSIGN(ChromeProtocolHandler);
 };
 
 }  // namespace
 
 URLDataManagerBackend::URLDataManagerBackend()
     : next_request_id_(0) {
   URLDataSource* shared_source = new SharedResourcesDataSource();
   URLDataSourceImpl* source_impl =
       new URLDataSourceImpl(shared_source->GetSource(), shared_source);
   AddDataSource(source_impl);
 }
 
 URLDataManagerBackend::~URLDataManagerBackend() {
-  for (DataSourceMap::iterator i = data_sources_.begin();
-       i != data_sources_.end(); ++i) {
-    i->second->backend_ = NULL;
-  }
+  for (const auto& i : data_sources_)
+    i.second->backend_ = nullptr;
   data_sources_.clear();
 }
 
 // static
 std::unique_ptr<net::URLRequestJobFactory::ProtocolHandler>
 URLDataManagerBackend::CreateProtocolHandler(
-    content::ResourceContext* resource_context,
+    ResourceContext* resource_context,
     bool is_incognito,
     ChromeBlobStorageContext* blob_storage_context) {
   DCHECK(resource_context);
   return base::WrapUnique(new ChromeProtocolHandler(
       resource_context, is_incognito, blob_storage_context));
 }
 
 void URLDataManagerBackend::AddDataSource(
     URLDataSourceImpl* source) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DataSourceMap::iterator i = data_sources_.find(source->source_name());
   if (i != data_sources_.end()) {
     if (!source->source()->ShouldReplaceExistingSource())
       return;
-    i->second->backend_ = NULL;
+    i->second->backend_ = nullptr;
   }
   data_sources_[source->source_name()] = source;
   source->backend_ = this;
 }
 
 bool URLDataManagerBackend::HasPendingJob(
     URLRequestChromeJob* job) const {
   for (PendingRequestMap::const_iterator i = pending_requests_.begin();
        i != pending_requests_.end(); ++i) {
     if (i->second == job)
@@ skipping 56 matching lines @@
   ResourceRequestInfo::GetRenderFrameForRequest(request,
                                                 &render_process_id,
                                                 &render_frame_id);
 
   // Forward along the request to the data source.
   base::MessageLoop* target_message_loop =
       source->source()->MessageLoopForRequestPath(path);
   if (!target_message_loop) {
     job->MimeTypeAvailable(source->source()->GetMimeType(path));
     // Eliminate potentially dangling pointer to avoid future use.
-    job = NULL;
+    job = nullptr;
 
     // The DataSource is agnostic to which thread StartDataRequest is called
     // on for this path.  Call directly into it from this thread, the IO
     // thread.
     source->source()->StartDataRequest(
         path, render_process_id, render_frame_id,
         base::Bind(&URLDataSourceImpl::SendResponse, source, request_id));
   } else {
     // URLRequestChromeJob should receive mime type before data. This
     // is guaranteed because request for mime type is placed in the
@@ skipping 21 matching lines @@
   if (i != data_sources_.end())
     return i->second.get();
 
   // No match using the host of the URL, so do a lookup using the scheme for
   // URLs on the form source_name://extra_bits/foo .
   i = data_sources_.find(url.scheme() + "://");
   if (i != data_sources_.end())
     return i->second.get();
 
   // No matches found, so give up.
-  return NULL;
+  return nullptr;
 }
 
 void URLDataManagerBackend::CallStartRequest(
     scoped_refptr<URLDataSourceImpl> source,
     const std::string& path,
     int render_process_id,
     int render_frame_id,
     int request_id) {
   if (BrowserThread::CurrentlyOn(BrowserThread::UI) &&
       render_process_id != -1 &&
       !RenderProcessHost::FromID(render_process_id)) {
     // Make the request fail if its initiating renderer is no longer valid.
     // This can happen when the IO thread posts this task just before the
     // renderer shuts down.
-    source->SendResponse(request_id, NULL);
+    source->SendResponse(request_id, nullptr);
     return;
   }
   source->source()->StartDataRequest(
       path,
       render_process_id,
       render_frame_id,
       base::Bind(&URLDataSourceImpl::SendResponse, source, request_id));
 }
 
 void URLDataManagerBackend::RemoveRequest(URLRequestChromeJob* job) {
@@ skipping 19 matching lines @@
     job->DataAvailable(bytes);
   }
 }
 
 namespace {
 
 class DevToolsJobFactory
     : public net::URLRequestJobFactory::ProtocolHandler {
  public:
   // |is_incognito| should be set for incognito profiles.
-  DevToolsJobFactory(content::ResourceContext* resource_context,
-                     bool is_incognito);
+  DevToolsJobFactory(ResourceContext* resource_context, bool is_incognito);
   ~DevToolsJobFactory() override;
 
   net::URLRequestJob* MaybeCreateJob(
       net::URLRequest* request,
       net::NetworkDelegate* network_delegate) const override;
 
  private:
   // |resource_context_| and |network_delegate_| are owned by ProfileIOData,
   // which owns this ProtocolHandler.
-  content::ResourceContext* const resource_context_;
+  ResourceContext* const resource_context_;
 
   // True when generated from an incognito profile.
   const bool is_incognito_;
 
   DISALLOW_COPY_AND_ASSIGN(DevToolsJobFactory);
 };
 
-DevToolsJobFactory::DevToolsJobFactory(
-    content::ResourceContext* resource_context,
-    bool is_incognito)
-    : resource_context_(resource_context),
-      is_incognito_(is_incognito) {
+DevToolsJobFactory::DevToolsJobFactory(ResourceContext* resource_context,
+                                       bool is_incognito)
+    : resource_context_(resource_context), is_incognito_(is_incognito) {
   DCHECK(resource_context_);
 }
 
 DevToolsJobFactory::~DevToolsJobFactory() {}
 
 net::URLRequestJob*
 DevToolsJobFactory::MaybeCreateJob(
     net::URLRequest* request, net::NetworkDelegate* network_delegate) const {
   return new URLRequestChromeJob(
       request, network_delegate,
       GetURLDataManagerForResourceContext(resource_context_), is_incognito_);
 }
 
 }  // namespace
 
-net::URLRequestJobFactory::ProtocolHandler*
-CreateDevToolsProtocolHandler(content::ResourceContext* resource_context,
-                              bool is_incognito) {
+net::URLRequestJobFactory::ProtocolHandler* CreateDevToolsProtocolHandler(
+    ResourceContext* resource_context,
+    bool is_incognito) {
   return new DevToolsJobFactory(resource_context, is_incognito);
 }
 
 }  // namespace content