Disable warning the user if a webRequest extension misbehaves

chrome/browser/extensions/extension_webrequest_time_tracker.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_time_tracker.h"
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/metrics/histogram.h"
 #include "chrome/browser/browser_process.h"
@@ skipping 17 matching lines @@
 const double kThresholdExcessiveDelay = 0.50;
 
 // If this many requests (of the past kMaxRequestsLogged) have had "too much"
 // delay, then we will warn the user.
 const size_t kNumModerateDelaysBeforeWarning = 50u;
 const size_t kNumExcessiveDelaysBeforeWarning = 10u;
 
 // Handles ExtensionWebRequestTimeTrackerDelegate calls on UI thread.
 void NotifyNetworkDelaysOnUI(void* profile,
                              std::set<std::string> extension_ids) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));

[Matt Perry, 2011/10/14 23:18:16]

why not just comment out the implementation here? then you don't have to worry
about compiler warnings

   Profile* p = reinterpret_cast<Profile*>(profile);
   if (!p || !g_browser_process->profile_manager()->IsValidProfile(p))
     return;
 
   ExtensionWarningSet* warnings =
       p->GetExtensionService()->extension_warnings();
 
   for (std::set<std::string>::const_iterator i = extension_ids.begin();
        i != extension_ids.end(); ++i) {
     warnings->SetWarning(ExtensionWarningSet::kNetworkDelay, *i);
@@ skipping 17 matching lines @@
       size_t num_delayed_messages,
       size_t total_num_messages,
       const std::set<std::string>& extension_ids) OVERRIDE;
 };
 
 void DefaultDelegate::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(&NotifyNetworkDelaysOnUI, profile, extension_ids));
+  // TODO(battre) Enable warning the user if extensions misbehave as soon as we
+  // have data that allows us to decide on reasonable limits for triggering the
+  // warnings.
+  // BrowserThread::PostTask(
+  //     BrowserThread::UI,
+  //     FROM_HERE,
+  //     base::Bind(&NotifyNetworkDelaysOnUI, profile, extension_ids));
 }
 
 void DefaultDelegate::NotifyModerateDelays(
     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(&NotifyNetworkDelaysOnUI, profile, extension_ids));
+  // TODO(battre) Enable warning the user if extensions misbehave as soon as we
+  // have data that allows us to decide on reasonable limits for triggering the
+  // warnings.
+  // BrowserThread::PostTask(
+  //     BrowserThread::UI,
+  //     FROM_HERE,
+  //     base::Bind(&NotifyNetworkDelaysOnUI, profile, extension_ids));
 }
 
 }  // namespace
 
 ExtensionWebRequestTimeTracker::RequestTimeLog::RequestTimeLog()
     : profile(NULL), completed(false) {
 }
 
 ExtensionWebRequestTimeTracker::RequestTimeLog::~RequestTimeLog() {
 }
@@ skipping 71 matching lines @@
   RequestTimeLog& log = request_time_logs_[request_id];
 
   // Ignore really short requests. Time spent on these is negligible, and any
   // extra delay the extension adds is likely to be noise.
   if (log.request_duration.InMilliseconds() < kMinRequestTimeToCareMs)
     return;
 
   double percentage =
       log.block_duration.InMillisecondsF() /
       log.request_duration.InMillisecondsF();
-  LOG(ERROR) << "WR percent " << request_id << ": " << log.url << ": " <<
+  VLOG(1) << "WR percent " << request_id << ": " << log.url << ": " <<
       log.block_duration.InMilliseconds() << "/" <<
       log.request_duration.InMilliseconds() << " = " << percentage;
 
   // TODO(mpcomplete): blame a specific extension. Maybe go through the list
   // of recent requests and find the extension that has caused the most delays.
   if (percentage > kThresholdExcessiveDelay) {
     excessive_delays_.insert(request_id);
     if (excessive_delays_.size() > kNumExcessiveDelaysBeforeWarning) {
-      LOG(ERROR) << "WR excessive delays:" << excessive_delays_.size();
+      VLOG(1) << "WR excessive delays:" << excessive_delays_.size();
       if (delegate_.get()) {
         delegate_->NotifyExcessiveDelays(log.profile,
                                          excessive_delays_.size(),
                                          request_ids_.size(),
                                          GetExtensionIds(log));
       }
     }
   } else if (percentage > kThresholdModerateDelay) {
     moderate_delays_.insert(request_id);
     if (moderate_delays_.size() + excessive_delays_.size() >
             kNumModerateDelaysBeforeWarning) {
-      LOG(ERROR) << "WR moderate delays:" << moderate_delays_.size();
+      VLOG(1) << "WR moderate delays:" << moderate_delays_.size();
       if (delegate_.get()) {
         delegate_->NotifyModerateDelays(
             log.profile,
             moderate_delays_.size() + excessive_delays_.size(),
             request_ids_.size(),
             GetExtensionIds(log));
       }
     }
   }
 }
@@ skipping 31 matching lines @@
   // When a request is redirected, we have no way of knowing how long the
   // request would have taken, so we can't say how much an extension slowed
   // down this request. Just ignore it.
   request_time_logs_.erase(request_id);
 }
 
 void ExtensionWebRequestTimeTracker::SetDelegate(
     ExtensionWebRequestTimeTrackerDelegate* delegate) {
   delegate_.reset(delegate);
 }