Change URL back to the previous one if the typed URL causes file download....

chrome/browser/renderer_host/buffered_resource_handler.cc

 // Copyright (c) 2006-2008 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/renderer_host/buffered_resource_handler.h"
 
 #include "base/histogram.h"
+#include "base/message_loop.h"
 #include "base/string_util.h"
+#include "base/task.h"
 #include "net/base/mime_sniffer.h"
 #include "chrome/browser/renderer_host/download_throttling_resource_handler.h"
 #include "chrome/browser/renderer_host/resource_dispatcher_host.h"
+#include "chrome/browser/tab_contents/tab_contents.h"
+#include "chrome/browser/tab_contents/tab_util.h"
 #include "chrome/common/url_constants.h"
 #include "net/base/mime_sniffer.h"
 #include "net/base/io_buffer.h"
 #include "net/http/http_response_headers.h"
 
 namespace {
 
 const int kMaxBytesToSniff = 512;
 
 void RecordSnifferMetrics(bool sniffing_blocked,
@@ skipping 11 matching lines @@
     static BooleanHistogram nosniff_empty_mime_type("nosniff.empty_mime_type");
     nosniff_empty_mime_type.SetFlags(kUmaTargetedHistogramFlag);
     nosniff_empty_mime_type.AddBoolean(mime_type.empty());
   }
 }
 
 }  // namespace
 
 BufferedResourceHandler::BufferedResourceHandler(ResourceHandler* handler,
                                                  ResourceDispatcherHost* host,
-                                                 URLRequest* request)
+                                                 URLRequest* request,
+                                                 int render_process_host_id,
+                                                 int render_view_id)
     : real_handler_(handler),
       host_(host),
       request_(request),
+      render_process_host_id_(render_process_host_id),
+      render_view_id_(render_view_id),
       bytes_read_(0),
       sniff_content_(false),
       should_buffer_(false),
       buffering_(false),
       finished_(false) {
 }
 
 bool BufferedResourceHandler::OnUploadProgress(int request_id,
                                                uint64 position,
                                                uint64 size) {
@@ skipping 186 matching lines @@
       // know how to display the content.  We follow Firefox here and show our
       // own error page instead of triggering a download.
       // TODO(abarth): We should abstract the response_code test, but this kind
       //               of check is scattered throughout our codebase.
       request_->SimulateError(net::ERR_FILE_NOT_FOUND);
       return false;
     }
 
     info->is_download = true;
 
+    host_->ui_loop()->PostTask(FROM_HERE, NewRunnableMethod(
+        this, &BufferedResourceHandler::NotifyDownload));
+
     scoped_refptr<DownloadThrottlingResourceHandler> download_handler =
         new DownloadThrottlingResourceHandler(host_,
                                            request_,
                                            request_->url(),
                                            info->process_id,
                                            info->route_id,
                                            request_id,
                                            in_complete);
     if (bytes_read_) {
       // a Read has already occurred and we need to copy the data into the
@@ skipping 12 matching lines @@
     real_handler_->OnResponseCompleted(info->request_id, status,
                                        std::string());
 
     // Ditch the old async handler that talks to the renderer for the new
     // download handler that talks to the DownloadManager.
     real_handler_ = download_handler;
   }
   return real_handler_->OnResponseStarted(request_id, response_);
 }
 
+void BufferedResourceHandler::NotifyDownload() {
+  TabContents* tab_contents =
+      tab_util::GetTabContentsByID(render_process_host_id_, render_view_id_);
+  tab_contents->MarkAsDownload();
+}
+
 bool BufferedResourceHandler::DidBufferEnough(int bytes_read) {
   const int kRequiredLength = 256;
 
   return bytes_read >= kRequiredLength;
 }