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

extensions/browser/api/web_request/web_request_api_helpers.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 "extensions/browser/api/web_request/web_request_api_helpers.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 14 matching lines @@
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/extensions_browser_client.h"
 #include "extensions/browser/runtime_data.h"
 #include "extensions/browser/warning_set.h"
 #include "extensions/common/extension_messages.h"
 #include "net/cookies/cookie_util.h"
 #include "net/cookies/parsed_cookie.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 "url/url_constants.h"
 
 // TODO(battre): move all static functions into an anonymous namespace at the
 // top of this file.
 
 using base::Time;
 using content::ResourceType;
 using net::cookie_util::ParsedRequestCookie;
 using net::cookie_util::ParsedRequestCookies;
@@ skipping 391 matching lines @@
 }
 
 void MergeCancelOfResponses(
     const EventResponseDeltas& deltas,
     bool* canceled,
     const net::BoundNetLog* net_log) {
   for (EventResponseDeltas::const_iterator i = deltas.begin();
        i != deltas.end(); ++i) {
     if ((*i)->cancel) {
       *canceled = true;
-      net_log->AddEvent(
-          net::NetLog::TYPE_CHROME_EXTENSION_ABORTED_REQUEST,
-          CreateNetLogExtensionIdCallback(i->get()));
+      net_log->AddEvent(net::NetLogEventType::CHROME_EXTENSION_ABORTED_REQUEST,
+                        CreateNetLogExtensionIdCallback(i->get()));
       break;
     }
   }
 }
 
 // Helper function for MergeRedirectUrlOfResponses() that allows ignoring
 // all redirects but those to data:// urls and about:blank. This is important
 // to treat these URLs as "cancel urls", i.e. URLs that extensions redirect
 // to if they want to express that they want to cancel a request. This reduces
 // the number of conflicts that we need to flag, as canceling is considered
@@ skipping 17 matching lines @@
         !(*delta)->new_url.SchemeIs(url::kDataScheme) &&
         (*delta)->new_url.spec() != "about:blank") {
       continue;
     }
 
     if (!redirected || *new_url == (*delta)->new_url) {
       *new_url = (*delta)->new_url;
       winning_extension_id = (*delta)->extension_id;
       redirected = true;
       net_log->AddEvent(
-          net::NetLog::TYPE_CHROME_EXTENSION_REDIRECTED_REQUEST,
+          net::NetLogEventType::CHROME_EXTENSION_REDIRECTED_REQUEST,
           CreateNetLogExtensionIdCallback(delta->get()));
     } else {
       conflicting_extensions->insert(
           extensions::Warning::CreateRedirectConflictWarning(
               (*delta)->extension_id,
               winning_extension_id,
               (*delta)->new_url,
               *new_url));
       net_log->AddEvent(
-          net::NetLog::TYPE_CHROME_EXTENSION_IGNORED_DUE_TO_CONFLICT,
+          net::NetLogEventType::CHROME_EXTENSION_IGNORED_DUE_TO_CONFLICT,
           CreateNetLogExtensionIdCallback(delta->get()));
     }
   }
   return redirected;
 }
 
 void MergeRedirectUrlOfResponses(
     const EventResponseDeltas& deltas,
     GURL* new_url,
     extensions::WarningSet* conflicting_extensions,
@@ skipping 304 matching lines @@
       // Perform all deletions and record which keys were deleted.
       {
         std::vector<std::string>::iterator key;
         for (key = (*delta)->deleted_request_headers.begin();
              key != (*delta)->deleted_request_headers.end();
              ++key) {
           request_headers->RemoveHeader(*key);
           removed_headers.insert(*key);
         }
       }
-      net_log->AddEvent(
-          net::NetLog::TYPE_CHROME_EXTENSION_MODIFIED_HEADERS,
-          base::Bind(&NetLogModificationCallback, delta->get()));
+      net_log->AddEvent(net::NetLogEventType::CHROME_EXTENSION_MODIFIED_HEADERS,
+                        base::Bind(&NetLogModificationCallback, delta->get()));
     } else {
       conflicting_extensions->insert(
           extensions::Warning::CreateRequestHeaderConflictWarning(
               (*delta)->extension_id, winning_extension_id,
               conflicting_header));
       net_log->AddEvent(
-          net::NetLog::TYPE_CHROME_EXTENSION_IGNORED_DUE_TO_CONFLICT,
+          net::NetLogEventType::CHROME_EXTENSION_IGNORED_DUE_TO_CONFLICT,
           CreateNetLogExtensionIdCallback(delta->get()));
     }
   }
 
   MergeCookiesInOnBeforeSendHeadersResponses(deltas, request_headers,
       conflicting_extensions, net_log);
 }
 
 // Retrives all cookies from |override_response_headers|.
 static ParsedResponseCookies GetResponseCookies(
@@ skipping 303 matching lines @@
       {
         for (i = (*delta)->added_response_headers.begin();
              i != (*delta)->added_response_headers.end(); ++i) {
           ResponseHeader lowercase_header(ToLowerCase(*i));
           if (added_headers.find(lowercase_header) != added_headers.end())
             continue;
           added_headers.insert(lowercase_header);
           (*override_response_headers)->AddHeader(i->first + ": " + i->second);
         }
       }
-      net_log->AddEvent(
-          net::NetLog::TYPE_CHROME_EXTENSION_MODIFIED_HEADERS,
-          CreateNetLogExtensionIdCallback(delta->get()));
+      net_log->AddEvent(net::NetLogEventType::CHROME_EXTENSION_MODIFIED_HEADERS,
+                        CreateNetLogExtensionIdCallback(delta->get()));
     } else {
       conflicting_extensions->insert(
           extensions::Warning::CreateResponseHeaderConflictWarning(
               (*delta)->extension_id, winning_extension_id,
               conflicting_header));
       net_log->AddEvent(
-          net::NetLog::TYPE_CHROME_EXTENSION_IGNORED_DUE_TO_CONFLICT,
+          net::NetLogEventType::CHROME_EXTENSION_IGNORED_DUE_TO_CONFLICT,
           CreateNetLogExtensionIdCallback(delta->get()));
     }
   }
 
   MergeCookiesInOnHeadersReceivedResponses(deltas, original_response_headers,
       override_response_headers, conflicting_extensions, net_log);
 
   GURL new_url;
   MergeRedirectUrlOfResponses(
       deltas, &new_url, conflicting_extensions, net_log);
@@ skipping 28 matching lines @@
       continue;
     bool different =
         auth_credentials->username() !=
             (*delta)->auth_credentials->username() ||
         auth_credentials->password() != (*delta)->auth_credentials->password();
     if (credentials_set && different) {
       conflicting_extensions->insert(
           extensions::Warning::CreateCredentialsConflictWarning(
               (*delta)->extension_id, winning_extension_id));
       net_log->AddEvent(
-          net::NetLog::TYPE_CHROME_EXTENSION_IGNORED_DUE_TO_CONFLICT,
+          net::NetLogEventType::CHROME_EXTENSION_IGNORED_DUE_TO_CONFLICT,
           CreateNetLogExtensionIdCallback(delta->get()));
     } else {
       net_log->AddEvent(
-          net::NetLog::TYPE_CHROME_EXTENSION_PROVIDE_AUTH_CREDENTIALS,
+          net::NetLogEventType::CHROME_EXTENSION_PROVIDE_AUTH_CREDENTIALS,
           CreateNetLogExtensionIdCallback(delta->get()));
       *auth_credentials = *(*delta)->auth_credentials;
       credentials_set = true;
       winning_extension_id = (*delta)->extension_id;
     }
   }
   return credentials_set;
 }
 
 void ClearCacheOnNavigation() {
@@ skipping 89 matching lines @@
   for (size_t i = 0; i < kResourceTypeStringsLength; ++i) {
     if (type_str == kResourceTypeStrings[i]) {
       found = true;
       types->push_back(kResourceTypeValues[i]);
     }
   }
   return found;
 }
 
 }  // namespace extension_web_request_api_helpers