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

net/url_request/sdch_dictionary_fetcher.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 "net/url_request/sdch_dictionary_fetcher.h"
 
 #include <stdint.h>
 #include <queue>
 #include <set>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
 #include "net/base/sdch_net_log_params.h"
 #include "net/http/http_response_headers.h"
 #include "net/log/net_log.h"
+#include "net/log/net_log_event_type.h"
 #include "net/url_request/redirect_info.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_status.h"
 #include "net/url_request/url_request_throttler_manager.h"
 
 namespace net {
 
 namespace {
 
 const int kBufferSize = 4096;
 
 // Map the bytes_read result from a read attempt and a URLRequest's
 // status into a single net return value.
 int GetReadResult(int rv, const URLRequest* request) {
   DCHECK_NE(ERR_IO_PENDING, rv);
 
   if (rv < 0) {
     rv = ERR_FAILED;
     request->net_log().AddEventWithNetErrorCode(
-        NetLog::TYPE_SDCH_DICTIONARY_FETCH_IMPLIED_ERROR, rv);
+        NetLogEventType::SDCH_DICTIONARY_FETCH_IMPLIED_ERROR, rv);
   }
 
   return rv;
 }
 
 struct FetchInfo {
   FetchInfo(const GURL& url,
             bool cache_only,
             const SdchDictionaryFetcher::OnDictionaryFetchedCallback& callback)
       : url(url), cache_only(cache_only), callback(callback) {}
@@ skipping 232 matching lines @@
   int load_flags = LOAD_DO_NOT_SEND_COOKIES | LOAD_DO_NOT_SAVE_COOKIES;
   if (info.cache_only)
     load_flags |= LOAD_ONLY_FROM_CACHE;
   current_request_->SetLoadFlags(load_flags);
 
   buffer_ = new IOBuffer(kBufferSize);
   dictionary_.reset(new std::string());
   current_callback_ = info.callback;
 
   current_request_->Start();
-  current_request_->net_log().AddEvent(NetLog::TYPE_SDCH_DICTIONARY_FETCH);
+  current_request_->net_log().AddEvent(NetLogEventType::SDCH_DICTIONARY_FETCH);
 
   return ERR_IO_PENDING;
 }
 
 int SdchDictionaryFetcher::DoReceivedRedirect(int rv) {
   // Fetching SDCH through a redirect is forbidden; it raises possible
   // security issues cross-origin, and isn't obviously useful within
   // an origin.
   ResetRequest();
   next_state_ = STATE_SEND_REQUEST;
@@ skipping 65 matching lines @@
                           current_request_->net_log(),
                           current_request_->was_cached());
   }
 
   ResetRequest();
   next_state_ = STATE_SEND_REQUEST;
   return OK;
 }
 
 }  // namespace net