Warn user in case extension delays network traffic too much.

chrome/browser/extensions/extension_webrequest_api.cc

 // Copyright (c) 2011 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/extension_webrequest_api.h"
 
 #include <algorithm>
 
+#include "base/bind.h"
 #include "base/json/json_writer.h"
 #include "base/metrics/histogram.h"
 #include "base/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
+#include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/extension_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_webrequest_api_constants.h"
-#include "chrome/browser/extensions/extension_webrequest_time_tracker.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/browser/renderer_host/web_cache_manager.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_error_utils.h"
 #include "chrome/common/extensions/url_pattern.h"
 #include "chrome/common/url_constants.h"
 #include "content/browser/browser_message_filter.h"
 #include "content/browser/browser_thread.h"
 #include "content/browser/renderer_host/resource_dispatcher_host.h"
 #include "content/browser/renderer_host/resource_dispatcher_host_request_info.h"
@@ skipping 102 matching lines @@
     modified_headers_.Append(Value::CreateStringValue(key + ": " + value));
   }
 
  private:
   ListValue modified_headers_;
   ListValue deleted_headers_;
 
   DISALLOW_COPY_AND_ASSIGN(NetLogModificationParameter);
 };
 
+// Handles ExtensionWebRequestTimeTrackerDelegate calls on UI thread.
+void NotifyExcessiveDelaysOnUI(void* profile,
+                               size_t num_delayed_messages,
+                               size_t total_num_messages,
+                               std::set<std::string> extension_ids) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  Profile* p = reinterpret_cast<Profile*>(profile);
+  if (!p || !g_browser_process->profile_manager()->IsValidProfile(p))
+    return;
+
+  ExtensionService* extension_service = p->GetExtensionService();
+
+  // We don't need to warn more than once.
+  if (extension_service->HasWarning(ExtensionServiceWarning::kNetworkDelay))
+    return;
+
+  // Override previous warning
+  extension_service->SetWarning(
+      ExtensionServiceWarning(ExtensionServiceWarning::kNetworkDelay,
+                              extension_ids));
+}
+
 // Returns the frame ID as it will be passed to the extension:
 // 0 if the navigation happens in the main frame, or the frame ID
 // modulo 32 bits otherwise.
 // Keep this in sync with the GetFrameId() function in
 // extension_webnavigation_api.cc.
 int GetFrameId(bool is_main_frame, int64 frame_id) {
   return is_main_frame ? 0 : static_cast<int>(frame_id);
 }
 
 bool IsWebRequestEvent(const std::string& event_name) {
@@ skipping 305 matching lines @@
   allow_extension_scheme = true;
 }
 
 // static
 ExtensionWebRequestEventRouter* ExtensionWebRequestEventRouter::GetInstance() {
   return Singleton<ExtensionWebRequestEventRouter>::get();
 }
 
 ExtensionWebRequestEventRouter::ExtensionWebRequestEventRouter()
     : request_time_tracker_(new ExtensionWebRequestTimeTracker) {
+  request_time_tracker_->SetDelegate(this);
 }
 
 ExtensionWebRequestEventRouter::~ExtensionWebRequestEventRouter() {
 }
 
+void ExtensionWebRequestEventRouter::NotifyExcessiveDelays(
+    void* profile,
+    size_t num_delayed_messages,
+    size_t total_num_messages,
+    const std::set<std::string>& extension_ids) {
+  BrowserThread::PostTask(
+      BrowserThread::UI,
+      FROM_HERE,
+      base::Bind(&NotifyExcessiveDelaysOnUI,
+                 profile, num_delayed_messages, total_num_messages,
+                 extension_ids));
+}
+
+void ExtensionWebRequestEventRouter::NotifyModerateDelays(
+    void* profile,
+    size_t num_delayed_messages,
+    size_t total_num_messages,
+    const std::set<std::string>& extension_ids) {
+  // We do not report these.

[Matt Perry, 2011/10/06 22:55:54]

why not?

The goal of the 2 buckets was to catch 2 bad cases:
- excessive: an extension takes a really long time on a small number of
requests, noticeably slowing down a couple page loads.
- moderate: an extension slows down many requests a medium amount. it might not
be noticeable in any given instance, but chrome "feels" slower overall.

[battre, 2011/10/07 14:09:24]

Done.

I had not understood this properly before. Thanks.

+}
+
 int ExtensionWebRequestEventRouter::OnBeforeRequest(
     void* profile,
     ExtensionInfoMap* extension_info_map,
     net::URLRequest* request,
     net::OldCompletionCallback* callback,
     GURL* new_url) {
   // TODO(jochen): Figure out what to do with events from the system context.
   if (!profile)
     return net::OK;
 
   if (!HasWebRequestScheme(request->url()))
     return net::OK;
 
   request_time_tracker_->LogRequestStartTime(request->identifier(),
                                              base::Time::Now(),
-                                             request->url());
+                                             request->url(),
+                                             profile);
 
   int extra_info_spec = 0;
   std::vector<const EventListener*> listeners =
       GetMatchingListeners(profile, extension_info_map, keys::kOnBeforeRequest,
                            request, &extra_info_spec);
   if (listeners.empty())
     return net::OK;
 
   if (GetAndSetSignaled(request->identifier(), kOnBeforeRequest))
     return net::OK;
@@ skipping 1081 matching lines @@
       profile_id(), extension_id(), event_name, sub_event_name, request_id,
       response.release());
 
   return true;
 }
 
 bool WebRequestHandlerBehaviorChanged::RunImpl() {
   WebCacheManager::GetInstance()->ClearCacheOnNavigation();
   return true;
 }