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

content/browser/service_worker/service_worker_url_request_job.cc

 // Copyright 2014 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/service_worker/service_worker_url_request_job.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <limits>
@@ skipping 22 matching lines @@
 #include "content/public/browser/blob_handle.h"
 #include "content/public/browser/resource_request_info.h"
 #include "content/public/browser/service_worker_context.h"
 #include "content/public/common/referrer.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
 #include "net/http/http_util.h"
 #include "net/log/net_log.h"
+#include "net/log/net_log_event_type.h"
 #include "storage/browser/blob/blob_data_builder.h"
 #include "storage/browser/blob/blob_data_handle.h"
 #include "storage/browser/blob/blob_storage_context.h"
 #include "ui/base/page_transition_types.h"
 
 namespace content {
 
 namespace {
 
-net::NetLog::EventType RequestJobResultToNetEventType(
+net::NetLogEventType RequestJobResultToNetEventType(
     ServiceWorkerMetrics::URLRequestJobResult result) {
-  using n = net::NetLog;
+  using n = net::NetLogEventType;
   using m = ServiceWorkerMetrics;
   switch (result) {
     case m::REQUEST_JOB_FALLBACK_RESPONSE:
-      return n::TYPE_SERVICE_WORKER_FALLBACK_RESPONSE;
+      return n::SERVICE_WORKER_FALLBACK_RESPONSE;
     case m::REQUEST_JOB_FALLBACK_FOR_CORS:
-      return n::TYPE_SERVICE_WORKER_FALLBACK_FOR_CORS;
+      return n::SERVICE_WORKER_FALLBACK_FOR_CORS;
     case m::REQUEST_JOB_HEADERS_ONLY_RESPONSE:
-      return n::TYPE_SERVICE_WORKER_HEADERS_ONLY_RESPONSE;
+      return n::SERVICE_WORKER_HEADERS_ONLY_RESPONSE;
     case m::REQUEST_JOB_STREAM_RESPONSE:
-      return n::TYPE_SERVICE_WORKER_STREAM_RESPONSE;
+      return n::SERVICE_WORKER_STREAM_RESPONSE;
     case m::REQUEST_JOB_BLOB_RESPONSE:
-      return n::TYPE_SERVICE_WORKER_BLOB_RESPONSE;
+      return n::SERVICE_WORKER_BLOB_RESPONSE;
     case m::REQUEST_JOB_ERROR_RESPONSE_STATUS_ZERO:
-      return n::TYPE_SERVICE_WORKER_ERROR_RESPONSE_STATUS_ZERO;
+      return n::SERVICE_WORKER_ERROR_RESPONSE_STATUS_ZERO;
     case m::REQUEST_JOB_ERROR_BAD_BLOB:
-      return n::TYPE_SERVICE_WORKER_ERROR_BAD_BLOB;
+      return n::SERVICE_WORKER_ERROR_BAD_BLOB;
     case m::REQUEST_JOB_ERROR_NO_PROVIDER_HOST:
-      return n::TYPE_SERVICE_WORKER_ERROR_NO_PROVIDER_HOST;
+      return n::SERVICE_WORKER_ERROR_NO_PROVIDER_HOST;
     case m::REQUEST_JOB_ERROR_NO_ACTIVE_VERSION:
-      return n::TYPE_SERVICE_WORKER_ERROR_NO_ACTIVE_VERSION;
+      return n::SERVICE_WORKER_ERROR_NO_ACTIVE_VERSION;
     case m::REQUEST_JOB_ERROR_FETCH_EVENT_DISPATCH:
-      return n::TYPE_SERVICE_WORKER_ERROR_FETCH_EVENT_DISPATCH;
+      return n::SERVICE_WORKER_ERROR_FETCH_EVENT_DISPATCH;
     case m::REQUEST_JOB_ERROR_BLOB_READ:
-      return n::TYPE_SERVICE_WORKER_ERROR_BLOB_READ;
+      return n::SERVICE_WORKER_ERROR_BLOB_READ;
     case m::REQUEST_JOB_ERROR_STREAM_ABORTED:
-      return n::TYPE_SERVICE_WORKER_ERROR_STREAM_ABORTED;
+      return n::SERVICE_WORKER_ERROR_STREAM_ABORTED;
     case m::REQUEST_JOB_ERROR_KILLED:
-      return n::TYPE_SERVICE_WORKER_ERROR_KILLED;
+      return n::SERVICE_WORKER_ERROR_KILLED;
     case m::REQUEST_JOB_ERROR_KILLED_WITH_BLOB:
-      return n::TYPE_SERVICE_WORKER_ERROR_KILLED_WITH_BLOB;
+      return n::SERVICE_WORKER_ERROR_KILLED_WITH_BLOB;
     case m::REQUEST_JOB_ERROR_KILLED_WITH_STREAM:
-      return n::TYPE_SERVICE_WORKER_ERROR_KILLED_WITH_STREAM;
+      return n::SERVICE_WORKER_ERROR_KILLED_WITH_STREAM;
     case m::REQUEST_JOB_ERROR_BAD_DELEGATE:
-      return n::TYPE_SERVICE_WORKER_ERROR_BAD_DELEGATE;
+      return n::SERVICE_WORKER_ERROR_BAD_DELEGATE;
     case m::REQUEST_JOB_ERROR_REQUEST_BODY_BLOB_FAILED:
-      return n::TYPE_SERVICE_WORKER_ERROR_REQUEST_BODY_BLOB_FAILED;
+      return n::SERVICE_WORKER_ERROR_REQUEST_BODY_BLOB_FAILED;
     // We can't log if there's no request; fallthrough.
     case m::REQUEST_JOB_ERROR_NO_REQUEST:
     // Obsolete types; fallthrough.
     case m::REQUEST_JOB_ERROR_DESTROYED:
     case m::REQUEST_JOB_ERROR_DESTROYED_WITH_BLOB:
     case m::REQUEST_JOB_ERROR_DESTROYED_WITH_STREAM:
     // Invalid type.
     case m::NUM_REQUEST_JOB_RESULT_TYPES:
       NOTREACHED() << result;
   }
   NOTREACHED() << result;
-  return n::TYPE_FAILED;
+  return n::FAILED;
 }
 
 }  // namespace
 
 class ServiceWorkerURLRequestJob::BlobConstructionWaiter {
  public:
   explicit BlobConstructionWaiter(ServiceWorkerURLRequestJob* owner)
       : owner_(owner), weak_factory_(this) {
     TRACE_EVENT_ASYNC_BEGIN1("ServiceWorker", "BlobConstructionWaiter", this,
                              "URL", owner_->request()->url().spec());
     owner_->request()->net_log().BeginEvent(
-        net::NetLog::TYPE_SERVICE_WORKER_WAITING_FOR_REQUEST_BODY_BLOB);
+        net::NetLogEventType::SERVICE_WORKER_WAITING_FOR_REQUEST_BODY_BLOB);
   }
 
   ~BlobConstructionWaiter() {
     owner_->request()->net_log().EndEvent(
-        net::NetLog::TYPE_SERVICE_WORKER_WAITING_FOR_REQUEST_BODY_BLOB,
+        net::NetLogEventType::SERVICE_WORKER_WAITING_FOR_REQUEST_BODY_BLOB,
         net::NetLog::BoolCallback("success", phase_ == Phase::SUCCESS));
     TRACE_EVENT_ASYNC_END1("ServiceWorker", "BlobConstructionWaiter", this,
                            "Success", phase_ == Phase::SUCCESS);
   }
 
   void RunOnComplete(const base::Callback<void(bool)>& callback) {
     DCHECK_EQ(static_cast<int>(Phase::INITIAL), static_cast<int>(phase_));
     phase_ = Phase::WAITING;
     num_pending_request_body_blobs_ = 0;
     callback_ = callback;
@@ skipping 255 matching lines @@
 void ServiceWorkerURLRequestJob::MaybeStartRequest() {
   if (is_started_ && response_type_ != NOT_DETERMINED) {
     // Start asynchronously.
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(&ServiceWorkerURLRequestJob::StartRequest,
                               weak_factory_.GetWeakPtr()));
   }
 }
 
 void ServiceWorkerURLRequestJob::StartRequest() {
-  request()->net_log().AddEvent(net::NetLog::TYPE_SERVICE_WORKER_START_REQUEST);
+  request()->net_log().AddEvent(
+      net::NetLogEventType::SERVICE_WORKER_START_REQUEST);
 
   switch (response_type_) {
     case NOT_DETERMINED:
       NOTREACHED();
       return;
 
     case FALLBACK_TO_NETWORK:
       FinalizeFallbackToNetwork();
       return;
 
@@ skipping 481 matching lines @@
       CreateFetchRequest(), active_worker, resource_type_, request()->net_log(),
       base::Bind(&ServiceWorkerURLRequestJob::DidPrepareFetchEvent,
                  weak_factory_.GetWeakPtr(), active_worker),
       base::Bind(&ServiceWorkerURLRequestJob::DidDispatchFetchEvent,
                  weak_factory_.GetWeakPtr())));
   worker_start_time_ = base::TimeTicks::Now();
   fetch_dispatcher_->Run();
 }
 
 }  // namespace content