Move ExtensionWarningService and ExtensionsWarningSet to extensions.

chrome/browser/extensions/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 "chrome/browser/extensions/api/web_request/web_request_api_helpers.h"
 
 #include <cmath>
 
 #include "base/bind.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/api/web_request/web_request_api.h"
-#include "chrome/browser/extensions/extension_warning_set.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/renderer_host/web_cache_manager.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_process_host.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/runtime_data.h"
+#include "extensions/browser/warning_set.h"
 #include "net/base/net_log.h"
 #include "net/cookies/cookie_util.h"
 #include "net/cookies/parsed_cookie.h"
 #include "net/http/http_util.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 extensions::ExtensionWarning;
+using extensions::Warning;

[James Cook, 2014/08/26 22:01:31]

nit: I either wouldn't do this, or add "using extensions::WarningSet". It seems
a bit odd to do one but not the other.

[Xi Han, 2014/08/27 13:32:54]

Removed.

 using net::cookie_util::ParsedRequestCookie;
 using net::cookie_util::ParsedRequestCookies;
 
 namespace extension_web_request_api_helpers {
 
 namespace {
 
 typedef std::vector<linked_ptr<net::ParsedCookie> > ParsedResponseCookies;
 
 static const char* kResourceTypeStrings[] = {
@@ skipping 361 matching lines @@
 // 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
 // a higher precedence operation that redirects.
 // Returns whether a redirect occurred.
 static bool MergeRedirectUrlOfResponsesHelper(
     const EventResponseDeltas& deltas,
     GURL* new_url,
-    extensions::ExtensionWarningSet* conflicting_extensions,
+    extensions::WarningSet* conflicting_extensions,
     const net::BoundNetLog* net_log,
     bool consider_only_cancel_scheme_urls) {
   bool redirected = false;
 
   // Extension that determines the |new_url|.
   std::string winning_extension_id;
   EventResponseDeltas::const_iterator delta;
   for (delta = deltas.begin(); delta != deltas.end(); ++delta) {
     if ((*delta)->new_url.is_empty())
       continue;
     if (consider_only_cancel_scheme_urls &&
         !(*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,
           CreateNetLogExtensionIdCallback(delta->get()));
     } else {
       conflicting_extensions->insert(
-          ExtensionWarning::CreateRedirectConflictWarning(
+          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,
           CreateNetLogExtensionIdCallback(delta->get()));
     }
   }
   return redirected;
 }
 
 void MergeRedirectUrlOfResponses(
     const EventResponseDeltas& deltas,
     GURL* new_url,
-    extensions::ExtensionWarningSet* conflicting_extensions,
+    extensions::WarningSet* conflicting_extensions,
     const net::BoundNetLog* net_log) {
 
   // First handle only redirects to data:// URLs and about:blank. These are a
   // special case as they represent a way of cancelling a request.
   if (MergeRedirectUrlOfResponsesHelper(
           deltas, new_url, conflicting_extensions, net_log, true)) {
     // If any extension cancelled a request by redirecting to a data:// URL or
     // about:blank, we don't consider the other redirects.
     return;
   }
 
   // Handle all other redirects.
   MergeRedirectUrlOfResponsesHelper(
       deltas, new_url, conflicting_extensions, net_log, false);
 }
 
 void MergeOnBeforeRequestResponses(
     const EventResponseDeltas& deltas,
     GURL* new_url,
-    extensions::ExtensionWarningSet* conflicting_extensions,
+    extensions::WarningSet* conflicting_extensions,
     const net::BoundNetLog* net_log) {
   MergeRedirectUrlOfResponses(deltas, new_url, conflicting_extensions, net_log);
 }
 
 static bool DoesRequestCookieMatchFilter(
     const ParsedRequestCookie& cookie,
     RequestCookie* filter) {
   if (!filter) return true;
   if (filter->name.get() && cookie.first != *filter->name) return false;
   if (filter->value.get() && cookie.second != *filter->value) return false;
@@ skipping 105 matching lines @@
         }
       }
     }
   }
   return modified;
 }
 
 void MergeCookiesInOnBeforeSendHeadersResponses(
     const EventResponseDeltas& deltas,
     net::HttpRequestHeaders* request_headers,
-    extensions::ExtensionWarningSet* conflicting_extensions,
+    extensions::WarningSet* conflicting_extensions,
     const net::BoundNetLog* net_log) {
   // Skip all work if there are no registered cookie modifications.
   bool cookie_modifications_exist = false;
   EventResponseDeltas::const_iterator delta;
   for (delta = deltas.begin(); delta != deltas.end(); ++delta) {
     cookie_modifications_exist |=
         !(*delta)->request_cookie_modifications.empty();
   }
   if (!cookie_modifications_exist)
     return;
@@ skipping 51 matching lines @@
       if (*i == key)
         return (*delta)->extension_id;
     }
   }
   return std::string();
 }
 
 void MergeOnBeforeSendHeadersResponses(
     const EventResponseDeltas& deltas,
     net::HttpRequestHeaders* request_headers,
-    extensions::ExtensionWarningSet* conflicting_extensions,
+    extensions::WarningSet* conflicting_extensions,
     const net::BoundNetLog* net_log) {
   EventResponseDeltas::const_iterator delta;
 
   // Here we collect which headers we have removed or set to new values
   // so far due to extensions of higher precedence.
   std::set<std::string> removed_headers;
   std::set<std::string> set_headers;
 
   // We assume here that the deltas are sorted in decreasing extension
   // precedence (i.e. decreasing extension installation time).
@@ skipping 80 matching lines @@
              ++key) {
           request_headers->RemoveHeader(*key);
           removed_headers.insert(*key);
         }
       }
       net_log->AddEvent(
           net::NetLog::TYPE_CHROME_EXTENSION_MODIFIED_HEADERS,
           base::Bind(&NetLogModificationCallback, delta->get()));
     } else {
       conflicting_extensions->insert(
-          ExtensionWarning::CreateRequestHeaderConflictWarning(
+          Warning::CreateRequestHeaderConflictWarning(
               (*delta)->extension_id, winning_extension_id,
               conflicting_header));
       net_log->AddEvent(
           net::NetLog::TYPE_CHROME_EXTENSION_IGNORED_DUE_TO_CONFLICT,
           CreateNetLogExtensionIdCallback(delta->get()));
     }
   }
 
   MergeCookiesInOnBeforeSendHeadersResponses(deltas, request_headers,
       conflicting_extensions, net_log);
@@ skipping 186 matching lines @@
       }
     }
   }
   return modified;
 }
 
 void MergeCookiesInOnHeadersReceivedResponses(
     const EventResponseDeltas& deltas,
     const net::HttpResponseHeaders* original_response_headers,
     scoped_refptr<net::HttpResponseHeaders>* override_response_headers,
-    extensions::ExtensionWarningSet* conflicting_extensions,
+    extensions::WarningSet* conflicting_extensions,
     const net::BoundNetLog* net_log) {
   // Skip all work if there are no registered cookie modifications.
   bool cookie_modifications_exist = false;
   EventResponseDeltas::const_reverse_iterator delta;
   for (delta = deltas.rbegin(); delta != deltas.rend(); ++delta) {
     cookie_modifications_exist |=
         !(*delta)->response_cookie_modifications.empty();
   }
   if (!cookie_modifications_exist)
     return;
@@ skipping 40 matching lines @@
     }
   }
   return std::string();
 }
 
 void MergeOnHeadersReceivedResponses(
     const EventResponseDeltas& deltas,
     const net::HttpResponseHeaders* original_response_headers,
     scoped_refptr<net::HttpResponseHeaders>* override_response_headers,
     GURL* allowed_unsafe_redirect_url,
-    extensions::ExtensionWarningSet* conflicting_extensions,
+    extensions::WarningSet* conflicting_extensions,
     const net::BoundNetLog* net_log) {
   EventResponseDeltas::const_iterator delta;
 
   // Here we collect which headers we have removed or added so far due to
   // extensions of higher precedence. Header keys are always stored as
   // lower case.
   std::set<ResponseHeader> removed_headers;
   std::set<ResponseHeader> added_headers;
 
   // We assume here that the deltas are sorted in decreasing extension
@@ skipping 49 matching lines @@
             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()));
     } else {
       conflicting_extensions->insert(
-          ExtensionWarning::CreateResponseHeaderConflictWarning(
+          Warning::CreateResponseHeaderConflictWarning(
               (*delta)->extension_id, winning_extension_id,
               conflicting_header));
       net_log->AddEvent(
           net::NetLog::TYPE_CHROME_EXTENSION_IGNORED_DUE_TO_CONFLICT,
           CreateNetLogExtensionIdCallback(delta->get()));
     }
   }
 
   MergeCookiesInOnHeadersReceivedResponses(deltas, original_response_headers,
       override_response_headers, conflicting_extensions, net_log);
@@ skipping 12 matching lines @@
     (*override_response_headers)->AddHeader("Location: " + new_url.spec());
     // Explicitly mark the URL as safe for redirection, to prevent the request
     // from being blocked because of net::ERR_UNSAFE_REDIRECT.
     *allowed_unsafe_redirect_url = new_url;
   }
 }
 
 bool MergeOnAuthRequiredResponses(
     const EventResponseDeltas& deltas,
     net::AuthCredentials* auth_credentials,
-    extensions::ExtensionWarningSet* conflicting_extensions,
+    extensions::WarningSet* conflicting_extensions,
     const net::BoundNetLog* net_log) {
   CHECK(auth_credentials);
   bool credentials_set = false;
   std::string winning_extension_id;
 
   for (EventResponseDeltas::const_iterator delta = deltas.begin();
        delta != deltas.end();
        ++delta) {
     if (!(*delta)->auth_credentials.get())
       continue;
     bool different =
         auth_credentials->username() !=
             (*delta)->auth_credentials->username() ||
         auth_credentials->password() != (*delta)->auth_credentials->password();
     if (credentials_set && different) {
       conflicting_extensions->insert(
-          ExtensionWarning::CreateCredentialsConflictWarning(
+          Warning::CreateCredentialsConflictWarning(
               (*delta)->extension_id, winning_extension_id));
       net_log->AddEvent(
           net::NetLog::TYPE_CHROME_EXTENSION_IGNORED_DUE_TO_CONFLICT,
           CreateNetLogExtensionIdCallback(delta->get()));
     } else {
       net_log->AddEvent(
           net::NetLog::TYPE_CHROME_EXTENSION_PROVIDE_AUTH_CREDENTIALS,
           CreateNetLogExtensionIdCallback(delta->get()));
       *auth_credentials = *(*delta)->auth_credentials;
       credentials_set = true;
@@ skipping 58 matching lines @@
   for (content::RenderProcessHost::iterator it =
            content::RenderProcessHost::AllHostsIterator();
        !it.IsAtEnd(); it.Advance()) {
     content::RenderProcessHost* host = it.GetCurrentValue();
     if (host->GetBrowserContext() == browser_context)
       SendExtensionWebRequestStatusToHost(host);
   }
 }
 
 }  // namespace extension_web_request_api_helpers