Add Resource Handler for creating Streams to forward to extensions

content/browser/loader/buffered_resource_handler.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 "content/browser/loader/buffered_resource_handler.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/string_util.h"
 #include "content/browser/download/download_resource_handler.h"
 #include "content/browser/download/download_stats.h"
 #include "content/browser/loader/certificate_resource_handler.h"
 #include "content/browser/loader/resource_dispatcher_host_impl.h"
 #include "content/browser/loader/resource_request_info_impl.h"
+#include "content/browser/loader/stream_resource_handler.h"
 #include "content/browser/plugin_service_impl.h"
+#include "content/browser/resource_context_impl.h"
+#include "content/browser/streams/stream.h"
+#include "content/browser/streams/stream_context.h"
+#include "content/browser/streams/stream_registry.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/download_id.h"
 #include "content/public/browser/download_save_info.h"
 #include "content/public/browser/resource_context.h"
 #include "content/public/browser/resource_dispatcher_host_delegate.h"
+#include "content/public/browser/stream_handle.h"
 #include "content/public/common/resource_response.h"
 #include "net/base/io_buffer.h"
 #include "net/base/mime_sniffer.h"
 #include "net/base/mime_util.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_content_disposition.h"
 #include "net/http/http_response_headers.h"
 #include "webkit/plugins/webplugininfo.h"
 
 namespace content {
@@ skipping 279 matching lines @@
   }
 
   if (!info->allow_download())
     return true;
 
   bool must_download = MustDownload();
   if (!must_download) {
     if (net::IsSupportedMimeType(mime_type))
       return true;
 
+    scoped_ptr<ResourceHandler> handler(MaybeInterceptAsStream());
+    if (handler)
+      return UseAlternateNextHandler(handler.Pass());
+
 #if defined(ENABLE_PLUGINS)
     bool stale;
     bool has_plugin = HasSupportingPlugin(&stale);
     if (stale) {
       // Refresh the plugins asynchronously.
       PluginServiceImpl::GetInstance()->GetPlugins(
           base::Bind(&BufferedResourceHandler::OnPluginsLoaded,
                      weak_ptr_factory_.GetWeakPtr()));
       *defer = true;
       return true;
@@ skipping 42 matching lines @@
   next_handler_->OnResponseCompleted(request_id, status, std::string());
 
   // This is handled entirely within the new ResourceHandler, so just reset the
   // original ResourceHandler.
   next_handler_ = new_handler.Pass();
   next_handler_->SetController(this);
 
   return CopyReadBufferToNextHandler(request_id);
 }
 
+scoped_ptr<ResourceHandler> BufferedResourceHandler::MaybeInterceptAsStream() {
+  ResourceRequestInfoImpl* info = ResourceRequestInfoImpl::ForRequest(request_);
+  const std::string& mime_type = response_->head.mime_type;
+
+  GURL security_origin;
+  std::string target_id;
+  if (host_->delegate() &&
+      host_->delegate()->ShouldInterceptResourceAsStream(info->GetContext(),

[darin (slow to review), 2013/03/19 06:12:51]

nit: return early to reduce overall indentation

[Zachary Kuznia, 2013/03/19 06:59:35]

Done.

+                                                         request_->url(),
+                                                         mime_type,
+                                                         &security_origin,
+                                                         &target_id)) {
+    StreamContext* stream_context =

[darin (slow to review), 2013/03/19 06:12:51]

you might consider modeling this code after CreateResourceHandlerForDownload,
which puts the handler allocation and delegate callback (DownloadStarting, but
in this case OnStreamCreated) on the ResourceDispatcherHostImpl.

[Zachary Kuznia, 2013/03/19 06:59:35]

Done.

+        GetStreamContextForResourceContext(info->GetContext());
+
+
+    scoped_ptr<StreamResourceHandler> handler(
+        new StreamResourceHandler(request_,
+                                  stream_context->registry(),
+                                  security_origin));
+
+    info->set_is_stream(true);
+    host_->delegate()->OnStreamCreated(
+        info->GetContext(),
+        info->GetChildID(),
+        info->GetRouteID(),
+        target_id,
+        handler->stream()->CreateHandle(),
+        mime_type,
+        request_->url());
+    return (scoped_ptr<ResourceHandler>(handler.release())).Pass();
+  }
+  return scoped_ptr<ResourceHandler>();
+}
+
 bool BufferedResourceHandler::ReplayReadCompleted(bool* defer) {
   DCHECK(read_buffer_);
 
   int request_id = ResourceRequestInfo::ForRequest(request_)->GetRequestID();
   bool result = next_handler_->OnReadCompleted(request_id, bytes_read_, defer);
 
   read_buffer_ = NULL;
   read_buffer_size_ = 0;
   bytes_read_ = 0;
 
@@ skipping 63 matching lines @@
     const std::vector<webkit::WebPluginInfo>& plugins) {
   bool defer = false;
   if (!ProcessResponse(&defer)) {
     controller()->Cancel();
   } else if (!defer) {
     controller()->Resume();
   }
 }
 
 }  // namespace content