Extracted NetLog class's inner enum types into their own enum classes and

net/url_request/url_request.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 "net/url_request/url_request.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 12 matching lines @@
 #include "net/base/host_port_pair.h"
 #include "net/base/load_flags.h"
 #include "net/base/load_timing_info.h"
 #include "net/base/net_errors.h"
 #include "net/base/network_change_notifier.h"
 #include "net/base/network_delegate.h"
 #include "net/base/upload_data_stream.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_util.h"
 #include "net/log/net_log.h"
+#include "net/log/net_log_event_type.h"
+#include "net/log/net_log_source_type.h"
 #include "net/ssl/ssl_cert_request_info.h"
 #include "net/url_request/redirect_info.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_error_job.h"
 #include "net/url_request/url_request_job.h"
 #include "net/url_request/url_request_job_manager.h"
 #include "net/url_request/url_request_netlog_params.h"
 #include "net/url_request/url_request_redirect_job.h"
 #include "url/gurl.h"
 #include "url/origin.h"
@@ skipping 141 matching lines @@
     OrphanJob();
 
   int deleted = context_->url_requests()->erase(this);
   CHECK_EQ(1, deleted);
 
   int net_error = OK;
   // Log error only on failure, not cancellation, as even successful requests
   // are "cancelled" on destruction.
   if (status_.status() == URLRequestStatus::FAILED)
     net_error = status_.error();
-  net_log_.EndEventWithNetErrorCode(NetLog::TYPE_REQUEST_ALIVE, net_error);
+  net_log_.EndEventWithNetErrorCode(NetLogEventType::REQUEST_ALIVE, net_error);
 }
 
 void URLRequest::set_upload(std::unique_ptr<UploadDataStream> upload) {
   upload_data_stream_ = std::move(upload);
 }
 
 const UploadDataStream* URLRequest::get_upload() const {
   return upload_data_stream_.get();
 }
 
@@ skipping 121 matching lines @@
   // Only log information to NetLog during startup and certain deferring calls
   // to delegates.  For all reads but the first, do nothing.
   if (!calling_delegate_ && !response_info_.request_time.is_null())
     return;
 
   LogUnblocked();
   blocked_by_ = blocked_by;
   use_blocked_by_as_load_param_ = false;
 
   net_log_.BeginEvent(
-      NetLog::TYPE_DELEGATE_INFO,
+      NetLogEventType::DELEGATE_INFO,
       NetLog::StringCallback("delegate_info", &blocked_by_));
 }
 
 void URLRequest::LogAndReportBlockedBy(const char* source) {
   LogBlockedBy(source);
   use_blocked_by_as_load_param_ = true;
 }
 
 void URLRequest::LogUnblocked() {
   if (blocked_by_.empty())
     return;
 
-  net_log_.EndEvent(NetLog::TYPE_DELEGATE_INFO);
+  net_log_.EndEvent(NetLogEventType::DELEGATE_INFO);
   blocked_by_.clear();
 }
 
 UploadProgress URLRequest::GetUploadProgress() const {
   if (!job_.get()) {
     // We haven't started or the request was cancelled
     return UploadProgress();
   }
   if (final_upload_progress_.position()) {
     // The first job completed and none of the subsequent series of
@@ skipping 193 matching lines @@
 
 URLRequest::URLRequest(const GURL& url,
                        RequestPriority priority,
                        Delegate* delegate,
                        const URLRequestContext* context,
                        NetworkDelegate* network_delegate)
     : context_(context),
       network_delegate_(network_delegate ? network_delegate
                                          : context->network_delegate()),
       net_log_(
-          BoundNetLog::Make(context->net_log(), NetLog::SOURCE_URL_REQUEST)),
+          BoundNetLog::Make(context->net_log(), NetLogSourceType::URL_REQUEST)),
       url_chain_(1, url),
       method_("GET"),
       referrer_policy_(CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE),
       first_party_url_policy_(NEVER_CHANGE_FIRST_PARTY_URL),
       load_flags_(LOAD_NORMAL),
       delegate_(delegate),
       status_(URLRequestStatus::FromError(OK)),
       is_pending_(false),
       is_redirecting_(false),
       redirect_limit_(kMaxRedirects),
       priority_(priority),
       identifier_(GenerateURLRequestIdentifier()),
       calling_delegate_(false),
       use_blocked_by_as_load_param_(false),
       before_request_callback_(base::Bind(&URLRequest::BeforeRequestComplete,
                                           base::Unretained(this))),
       has_notified_completion_(false),
       received_response_content_length_(0),
       creation_time_(base::TimeTicks::Now()) {
   // Sanity check out environment.
   DCHECK(base::MessageLoop::current())
       << "The current base::MessageLoop must exist";
 
   context->url_requests()->insert(this);
-  net_log_.BeginEvent(NetLog::TYPE_REQUEST_ALIVE);
+  net_log_.BeginEvent(NetLogEventType::REQUEST_ALIVE);
 }
 
 void URLRequest::BeforeRequestComplete(int error) {
   DCHECK(!job_.get());
   DCHECK_NE(ERR_IO_PENDING, error);
 
   // Check that there are no callbacks to already canceled requests.
   DCHECK_NE(URLRequestStatus::CANCELED, status_.status());
 
   OnCallToDelegateComplete();
 
   if (error != OK) {
     std::string source("delegate");
-    net_log_.AddEvent(NetLog::TYPE_CANCELLED,
+    net_log_.AddEvent(NetLogEventType::CANCELLED,
                       NetLog::StringCallback("source", &source));
     StartJob(new URLRequestErrorJob(this, network_delegate_, error));
   } else if (!delegate_redirect_url_.is_empty()) {
     GURL new_url;
     new_url.Swap(&delegate_redirect_url_);
 
     URLRequestRedirectJob* job = new URLRequestRedirectJob(
         this, network_delegate_, new_url,
         // Use status code 307 to preserve the method, so POST requests work.
         URLRequestRedirectJob::REDIRECT_307_TEMPORARY_REDIRECT, "Delegate");
     StartJob(job);
   } else {
     StartJob(URLRequestJobManager::GetInstance()->CreateJob(
         this, network_delegate_));
   }
 }
 
 void URLRequest::StartJob(URLRequestJob* job) {
   // TODO(mmenke): Remove ScopedTracker below once crbug.com/456327 is fixed.
   tracked_objects::ScopedTracker tracking_profile(
       FROM_HERE_WITH_EXPLICIT_FUNCTION("456327 URLRequest::StartJob"));
 
   DCHECK(!is_pending_);
   DCHECK(!job_.get());
 
   net_log_.BeginEvent(
-      NetLog::TYPE_URL_REQUEST_START_JOB,
+      NetLogEventType::URL_REQUEST_START_JOB,
       base::Bind(&NetLogURLRequestStartCallback,
                  &url(), &method_, load_flags_, priority_,
                  upload_data_stream_ ? upload_data_stream_->identifier() : -1));
 
   job_.reset(job);
   job_->SetExtraRequestHeaders(extra_request_headers_);
   job_->SetPriority(priority_);
 
   if (upload_data_stream_.get())
     job_->SetUpload(upload_data_stream_.get());
 
   is_pending_ = true;
   is_redirecting_ = false;
 
   response_info_.was_cached = false;
 
   if (GURL(referrer_) != URLRequestJob::ComputeReferrerForRedirect(
                              referrer_policy_, referrer_, url())) {
     if (!network_delegate_ ||
         !network_delegate_->CancelURLRequestWithPolicyViolatingReferrerHeader(
             *this, url(), GURL(referrer_))) {
       referrer_.clear();
     } else {
       // We need to clear the referrer anyway to avoid an infinite recursion
       // when starting the error job.
       referrer_.clear();
       std::string source("delegate");
-      net_log_.AddEvent(NetLog::TYPE_CANCELLED,
+      net_log_.AddEvent(NetLogEventType::CANCELLED,
                         NetLog::StringCallback("source", &source));
       RestartWithJob(new URLRequestErrorJob(
           this, network_delegate_, ERR_BLOCKED_BY_CLIENT));
       return;
     }
   }
 
   // Start() always completes asynchronously.
   //
   // Status is generally set by URLRequestJob itself, but Start() calls
@@ skipping 44 matching lines @@
 
   // If the URL request already has an error status, then canceling is a no-op.
   // Plus, we don't want to change the error status once it has been set.
   if (status_.is_success()) {
     status_ = URLRequestStatus(URLRequestStatus::CANCELED, error);
     response_info_.ssl_info = ssl_info;
 
     // If the request hasn't already been completed, log a cancellation event.
     if (!has_notified_completion_) {
       // Don't log an error code on ERR_ABORTED, since that's redundant.
-      net_log_.AddEventWithNetErrorCode(NetLog::TYPE_CANCELLED,
+      net_log_.AddEventWithNetErrorCode(NetLogEventType::CANCELLED,
                                         error == ERR_ABORTED ? OK : error);
     }
   }
 
   if (is_pending_ && job_.get())
     job_->Kill();
 
   // We need to notify about the end of this job here synchronously. The
   // Job sends an asynchronous notification but by the time this is processed,
   // our |context_| is NULL.
@@ skipping 87 matching lines @@
 }
 
 void URLRequest::NotifyResponseStarted(const URLRequestStatus& status) {
   // Change status if there was an error.
   if (status.status() != URLRequestStatus::SUCCESS)
     set_status(status);
 
   int net_error = OK;
   if (!status_.is_success())
     net_error = status_.error();
-  net_log_.EndEventWithNetErrorCode(NetLog::TYPE_URL_REQUEST_START_JOB,
+  net_log_.EndEventWithNetErrorCode(NetLogEventType::URL_REQUEST_START_JOB,
                                     net_error);
 
   URLRequestJob* job =
       URLRequestJobManager::GetInstance()->MaybeInterceptResponse(
           this, network_delegate_);
   if (job) {
     RestartWithJob(job);
   } else {
     // In some cases (e.g. an event was canceled), we might have sent the
     // completion event and receive a NotifyResponseStarted() later.
@@ skipping 56 matching lines @@
 
   status_ = URLRequestStatus::FromError(ERR_IO_PENDING);
   job_->ContinueDespiteLastError();
 }
 
 void URLRequest::PrepareToRestart() {
   DCHECK(job_.get());
 
   // Close the current URL_REQUEST_START_JOB, since we will be starting a new
   // one.
-  net_log_.EndEvent(NetLog::TYPE_URL_REQUEST_START_JOB);
+  net_log_.EndEvent(NetLogEventType::URL_REQUEST_START_JOB);
 
   OrphanJob();
 
   response_info_ = HttpResponseInfo();
   response_info_.request_time = base::Time::Now();
 
   load_timing_info_ = LoadTimingInfo();
   load_timing_info_.request_start_time = response_info_.request_time;
   load_timing_info_.request_start = base::TimeTicks::Now();
 
@@ skipping 13 matching lines @@
   //   that the callback becomes invalid.
   job_->Kill();
   job_ = NULL;
 }
 
 int URLRequest::Redirect(const RedirectInfo& redirect_info) {
   // Matches call in NotifyReceivedRedirect.
   OnCallToDelegateComplete();
   if (net_log_.IsCapturing()) {
     net_log_.AddEvent(
-        NetLog::TYPE_URL_REQUEST_REDIRECTED,
+        NetLogEventType::URL_REQUEST_REDIRECTED,
         NetLog::StringCallback("location",
                                &redirect_info.new_url.possibly_invalid_spec()));
   }
 
   // TODO(davidben): Pass the full RedirectInfo to the NetworkDelegate.
   if (network_delegate_)
     network_delegate_->NotifyBeforeRedirect(this, redirect_info.new_url);
 
   if (redirect_limit_ <= 0) {
     DVLOG(1) << "disallowing redirect: exceeds limit";
@@ skipping 87 matching lines @@
     // have MAXIMUM_PRIORITY for release mode.
     return;
   }
 
   if (priority_ == priority)
     return;
 
   priority_ = priority;
   if (job_.get()) {
     net_log_.AddEvent(
-        NetLog::TYPE_URL_REQUEST_SET_PRIORITY,
+        NetLogEventType::URL_REQUEST_SET_PRIORITY,
         NetLog::StringCallback("priority", RequestPriorityToString(priority_)));
     job_->SetPriority(priority_);
   }
 }
 
 void URLRequest::NotifyAuthRequired(AuthChallengeInfo* auth_info) {
   NetworkDelegate::AuthRequiredResponse rv =
       NetworkDelegate::AUTH_REQUIRED_RESPONSE_NO_ACTION;
   auth_info_ = auth_info;
   if (network_delegate_) {
@@ skipping 147 matching lines @@
   has_notified_completion_ = true;
   if (network_delegate_)
     network_delegate_->NotifyCompleted(this, job_.get() != NULL,
                                        status_.error());
 }
 
 void URLRequest::OnCallToDelegate() {
   DCHECK(!calling_delegate_);
   DCHECK(blocked_by_.empty());
   calling_delegate_ = true;
-  net_log_.BeginEvent(NetLog::TYPE_URL_REQUEST_DELEGATE);
+  net_log_.BeginEvent(NetLogEventType::URL_REQUEST_DELEGATE);
 }
 
 void URLRequest::OnCallToDelegateComplete() {
   // This should have been cleared before resuming the request.
   DCHECK(blocked_by_.empty());
   if (!calling_delegate_)
     return;
   calling_delegate_ = false;
-  net_log_.EndEvent(NetLog::TYPE_URL_REQUEST_DELEGATE);
+  net_log_.EndEvent(NetLogEventType::URL_REQUEST_DELEGATE);
 }
 
 void URLRequest::GetConnectionAttempts(ConnectionAttempts* out) const {
   if (job_)
     job_->GetConnectionAttempts(out);
   else
     out->clear();
 }
 
 void URLRequest::set_status(URLRequestStatus status) {
   DCHECK(status_.is_io_pending() || status_.is_success() ||
          (!status.is_success() && !status.is_io_pending()));
   status_ = status;
 }
 
 }  // namespace net