Improve error messaging of webRequest API in case of conflicts

chrome/browser/extensions/api/web_request/web_request_api.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.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "base/json/json_writer.h"
 #include "base/metrics/histogram.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_content_browser_client.h"
 #include "chrome/browser/extensions/api/declarative_webrequest/request_stage.h"
 #include "chrome/browser/extensions/api/declarative_webrequest/webrequest_rule.h"
 #include "chrome/browser/extensions/api/declarative_webrequest/webrequest_rules_registry.h"
 #include "chrome/browser/extensions/api/web_navigation/web_navigation_api_helpers.h"
 #include "chrome/browser/extensions/api/web_request/upload_data_presenter.h"
 #include "chrome/browser/extensions/api/web_request/web_request_api_constants.h"
 #include "chrome/browser/extensions/api/web_request/web_request_api_helpers.h"
 #include "chrome/browser/extensions/api/web_request/web_request_time_tracker.h"
 #include "chrome/browser/extensions/event_router.h"
 #include "chrome/browser/extensions/extension_info_map.h"
 #include "chrome/browser/extensions/extension_prefs.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_tab_id_map.h"
+#include "chrome/browser/extensions/extension_warning_service.h"
+#include "chrome/browser/extensions/extension_warning_set.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/renderer_host/chrome_render_message_filter.h"
 #include "chrome/common/extensions/api/web_request.h"
 #include "chrome/common/extensions/event_filtering_info.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/extension_error_utils.h"
 #include "chrome/common/extensions/extension_messages.h"
 #include "chrome/common/extensions/features/feature.h"
@@ skipping 14 matching lines @@
 #include "ui/base/l10n/l10n_util.h"
 
 using base::DictionaryValue;
 using base::ListValue;
 using base::StringValue;
 using chrome::VersionInfo;
 using content::BrowserMessageFilter;
 using content::BrowserThread;
 using content::ResourceRequestInfo;
 using extensions::Extension;
+using extensions::ExtensionWarning;
+using extensions::ExtensionWarningService;
+using extensions::ExtensionWarningSet;
 using extensions::Feature;
-
 using extensions::web_navigation_api_helpers::GetFrameId;
 
 namespace helpers = extension_web_request_api_helpers;
 namespace keys = extension_web_request_api_constants;
 namespace web_request = extensions::api::web_request;
 
 namespace {
 
 // List of all the webRequest events.
 const char* const kWebRequestEvents[] = {
@@ skipping 1305 matching lines @@
   BlockedRequest& blocked_request = blocked_requests_[request_id];
   CHECK(blocked_request.num_handlers_blocking == 0);
   helpers::EventResponseDeltas& deltas = blocked_request.response_deltas;
   base::TimeDelta block_time =
       base::Time::Now() - blocked_request.blocking_time;
   request_time_tracker_->IncrementTotalBlockTime(request_id, block_time);
 
   bool credentials_set = false;
 
   deltas.sort(&helpers::InDecreasingExtensionInstallationTimeOrder);
-  std::set<std::string> conflicting_extensions;
+  ExtensionWarningSet warnings;
 
   bool canceled = false;
   helpers::MergeCancelOfResponses(
       blocked_request.response_deltas,
       &canceled,
       blocked_request.net_log);
 
   if (blocked_request.event == kOnBeforeRequest) {
     CHECK(!blocked_request.callback.is_null());
     helpers::MergeOnBeforeRequestResponses(
         blocked_request.response_deltas,
         blocked_request.new_url,
-        &conflicting_extensions,
+        &warnings,
         blocked_request.net_log);
   } else if (blocked_request.event == kOnBeforeSendHeaders) {
     CHECK(!blocked_request.callback.is_null());
     helpers::MergeOnBeforeSendHeadersResponses(
         blocked_request.response_deltas,
         blocked_request.request_headers,
-        &conflicting_extensions,
+        &warnings,
         blocked_request.net_log);
   } else if (blocked_request.event == kOnHeadersReceived) {
     CHECK(!blocked_request.callback.is_null());
     helpers::MergeOnHeadersReceivedResponses(
         blocked_request.response_deltas,
         blocked_request.original_response_headers.get(),
         blocked_request.override_response_headers,
-        &conflicting_extensions,
+        &warnings,
         blocked_request.net_log);
   } else if (blocked_request.event == kOnAuthRequired) {
     CHECK(blocked_request.callback.is_null());
     CHECK(!blocked_request.auth_callback.is_null());
     credentials_set = helpers::MergeOnAuthRequiredResponses(
        blocked_request.response_deltas,
        blocked_request.auth_credentials,
-       &conflicting_extensions,
+       &warnings,
        blocked_request.net_log);
   } else {
     NOTREACHED();
   }
 
-  if (!conflicting_extensions.empty()) {
+  if (!warnings.empty()) {
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
-        base::Bind(&ExtensionWarningSet::NotifyWarningsOnUI,
-                   profile,
-                   conflicting_extensions,
-                   ExtensionWarningSet::kNetworkConflict));
+        base::Bind(&ExtensionWarningService::NotifyWarningsOnUI,
+                   profile, warnings));
   }
 
   if (canceled) {
     request_time_tracker_->SetRequestCanceled(request_id);
   } else if (blocked_request.new_url &&
              !blocked_request.new_url->is_empty()) {
     request_time_tracker_->SetRequestRedirected(request_id);
   }
 
   // This triggers onErrorOccurred if canceled is true.
@@ skipping 412 matching lines @@
   QuotaLimitHeuristic::BucketMapper* bucket_mapper =
       new QuotaLimitHeuristic::SingletonBucketMapper();
   ClearCacheQuotaHeuristic* heuristic =
       new ClearCacheQuotaHeuristic(config, bucket_mapper);
   heuristics->push_back(heuristic);
 }
 
 void WebRequestHandlerBehaviorChanged::OnQuotaExceeded(
     const std::string& violation_error) {
   // Post warning message.
-  std::set<std::string> extension_ids;
-  extension_ids.insert(extension_id());
+  ExtensionWarningSet warnings;
+  warnings.insert(
+      ExtensionWarning::CreateRepeatedCacheFlushesWarning(extension_id()));
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
-      base::Bind(&ExtensionWarningSet::NotifyWarningsOnUI,
-                 profile_id(),
-                 extension_ids,
-                 ExtensionWarningSet::kRepeatedCacheFlushes));
+      base::Bind(&ExtensionWarningService::NotifyWarningsOnUI,
+                 profile_id(), warnings));
 
   // Continue gracefully.
   Run();
 }
 
 bool WebRequestHandlerBehaviorChanged::RunImpl() {
   helpers::ClearCacheOnNavigation();
   return true;
 }
 
@@ skipping 15 matching lines @@
       } else if ((*it)->name().find("AdBlock") != std::string::npos) {
         adblock = true;
       } else {
         other = true;
       }
     }
   }
 
   host->Send(new ExtensionMsg_UsingWebRequestAPI(adblock, adblock_plus, other));
 }