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

content/browser/appcache/appcache_url_request_job.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/appcache/appcache_url_request_job.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "content/browser/appcache/appcache.h"
 #include "content/browser/appcache/appcache_group.h"
 #include "content/browser/appcache/appcache_histograms.h"
 #include "content/browser/appcache/appcache_host.h"
 #include "content/browser/appcache/appcache_service_impl.h"
 #include "net/base/io_buffer.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_util.h"
 #include "net/log/net_log.h"
+#include "net/log/net_log_event_type.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_status.h"
 
 namespace content {
 
 AppCacheURLRequestJob::AppCacheURLRequestJob(
     net::URLRequest* request,
     net::NetworkDelegate* network_delegate,
     AppCacheStorage* storage,
     AppCacheHost* host,
@@ skipping 75 matching lines @@
       // cause a new job to be created to retrieve the resource from the
       // network. Our caller is responsible for arranging to not re-intercept
       // the same request.
       NotifyRestartRequired();
       break;
 
     case ERROR_DELIVERY:
       AppCacheHistograms::AddErrorJobStartDelaySample(
           base::TimeTicks::Now() - start_time_tick_);
       request()->net_log().AddEvent(
-          net::NetLog::TYPE_APPCACHE_DELIVERING_ERROR_RESPONSE);
+          net::NetLogEventType::APPCACHE_DELIVERING_ERROR_RESPONSE);
       NotifyStartError(net::URLRequestStatus(net::URLRequestStatus::FAILED,
                                              net::ERR_FAILED));
       break;
 
     case APPCACHED_DELIVERY:
       if (entry_.IsExecutable()) {
         BeginExecutableHandlerDelivery();
         return;
       }
       AppCacheHistograms::AddAppCacheJobStartDelaySample(
           base::TimeTicks::Now() - start_time_tick_);
       request()->net_log().AddEvent(
-          is_fallback_ ?
-              net::NetLog::TYPE_APPCACHE_DELIVERING_FALLBACK_RESPONSE :
-              net::NetLog::TYPE_APPCACHE_DELIVERING_CACHED_RESPONSE);
+          is_fallback_
+              ? net::NetLogEventType::APPCACHE_DELIVERING_FALLBACK_RESPONSE
+              : net::NetLogEventType::APPCACHE_DELIVERING_CACHED_RESPONSE);
       storage_->LoadResponseInfo(manifest_url_, entry_.response_id(), this);
       break;
 
     default:
       NOTREACHED();
       break;
   }
 }
 
 void AppCacheURLRequestJob::BeginExecutableHandlerDelivery() {
   DCHECK(base::CommandLine::ForCurrentProcess()->HasSwitch(
       kEnableExecutableHandlers));
   if (!storage_->service()->handler_factory()) {
     BeginErrorDelivery("missing handler factory");
     return;
   }
 
   request()->net_log().AddEvent(
-      net::NetLog::TYPE_APPCACHE_DELIVERING_EXECUTABLE_RESPONSE);
+      net::NetLogEventType::APPCACHE_DELIVERING_EXECUTABLE_RESPONSE);
 
   // We defer job delivery until the executable handler is spun up and
   // provides a response. The sequence goes like this...
   //
   // 1. First we load the cache.
   // 2. Then if the handler is not spun up, we load the script resource which
   //    is needed to spin it up.
   // 3. Then we ask then we ask the handler to compute a response.
   // 4. Finally we deilver that response to the caller.
   storage_->LoadCache(cache_id_, this);
@@ skipping 283 matching lines @@
   if (ranges.size() == 1U)
     range_requested_ = ranges[0];
 }
 
 void AppCacheURLRequestJob::NotifyRestartRequired() {
   on_prepare_to_restart_callback_.Run();
   URLRequestJob::NotifyRestartRequired();
 }
 
 }  // namespace content