Anti-DDoS enhancements: Log to net log, UMA stats, improved policy.

chrome/common/net/url_fetcher.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/common/net/url_fetcher.h"
 
 #include <set>
 
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
@@ skipping 40 matching lines @@
   // us.  If our caller hasn't had time to fully construct us and take a
   // reference, the IO thread could interrupt things, run a task, Release()
   // us, and destroy us, leaving the caller with an already-destroyed object
   // when construction finishes.
   void Start();
 
   // Stops any in-progress load and ensures no callback will happen.  It is
   // safe to call this multiple times.
   void Stop();
 
-  // Reports that the received content was malformed.
+  // Reports that the received content was malformed (i.e. failed parsing
+  // or validation).  This makes the throttling logic that does exponential
+  // back-off when servers are having problems treat the current request as
+  // a failure.  Your call to this method will be ignored if your request is
+  // already considered a failure based on the HTTP response code or response
+  // headers.
   void ReceivedContentWasMalformed();
 
   // Overridden from net::URLRequest::Delegate:
   virtual void OnResponseStarted(net::URLRequest* request);
   virtual void OnReadCompleted(net::URLRequest* request, int bytes_read);
 
   URLFetcher::Delegate* delegate() const { return delegate_; }
   static void CancelAll();
 
  private:
@@ skipping 726 matching lines @@
   status_ = status;
 
   // Checks the response from server.
   if (response_code_ >= 500 ||
       status.os_error() == net::ERR_TEMPORARILY_THROTTLED) {
     // When encountering a server error, we will send the request again
     // after backoff time.
     ++num_retries_;
     // Restarts the request if we still need to notify the delegate.
     if (delegate_) {
+      // Note that backoff_delay_ may be 0 because (a) the URLRequestThrottler
+      // code does not necessarily back off on the first error, and (b) it
+      // only backs off on some of the 5xx status codes.
       fetcher_->backoff_delay_ = backoff_release_time_ - base::TimeTicks::Now();
       if (fetcher_->backoff_delay_ < base::TimeDelta())
         fetcher_->backoff_delay_ = base::TimeDelta();
 
       if (fetcher_->automatically_retry_on_5xx_ &&
           num_retries_ <= fetcher_->max_retries()) {
         io_message_loop_proxy_->PostTask(
             FROM_HERE,
             NewRunnableMethod(this, &Core::StartURLRequestWhenAppropriate));
       } else {
         InformDelegateFetchIsComplete();
       }
     }
   } else {
     if (delegate_) {
       fetcher_->backoff_delay_ = base::TimeDelta();
       InformDelegateFetchIsComplete();
     }
   }
 }
 
 void URLFetcher::Core::InformDelegateFetchIsComplete() {
   delegate_->OnURLFetchComplete(fetcher_);
 }
 
 void URLFetcher::Core::NotifyMalformedContent() {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
-  if (url_throttler_entry_ != NULL)
-    url_throttler_entry_->ReceivedContentWasMalformed();
+  if (url_throttler_entry_ != NULL) {
+    int status_code = response_code_;
+    if (status_code == kInvalidHttpResponseCode) {
+      // The status code will generally be known by the time clients
+      // call the |ReceivedContentWasMalformed()| function (which ends up
+      // calling the current function) but if it's not, we need to assume
+      // the response was successful so that the total failure count
+      // used to calculate exponential back-off goes up.
+      status_code = 200;
+    }
+    url_throttler_entry_->ReceivedContentWasMalformed(status_code);
+  }
 }
 
 void URLFetcher::Core::ReleaseRequest() {
   request_.reset();
   g_registry.Get().RemoveURLFetcherCore(this);
 }
 
 base::TimeTicks URLFetcher::Core::GetBackoffReleaseTime() {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
   DCHECK(original_url_throttler_entry_ != NULL);
@@ skipping 168 matching lines @@
 }
 
 // static
 int URLFetcher::GetNumFetcherCores() {
   return Core::g_registry.Get().size();
 }
 
 URLFetcher::Delegate* URLFetcher::delegate() const {
   return core_->delegate();
 }