Forward MIME types to BrowserPlugin when a viewer is specified.

content/browser/loader/stream_resource_handler.cc

 // Copyright (c) 2013 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/stream_resource_handler.h"
 
 #include "base/guid.h"
 #include "base/logging.h"
 #include "content/browser/streams/stream.h"
 #include "content/browser/streams/stream_registry.h"
 #include "content/public/browser/resource_controller.h"
 #include "content/public/common/url_constants.h"
 #include "net/base/io_buffer.h"
 #include "net/url_request/url_request_status.h"
 
 namespace content {
 
-StreamResourceHandler::StreamResourceHandler(net::URLRequest* request,
-                                             StreamRegistry* registry,
-                                             const GURL& origin)
+StreamResourceHandler::StreamResourceHandler(
+    net::URLRequest* request,
+    StreamRegistry* registry,
+    const GURL& origin,
+    const std::string& payload)
     : ResourceHandler(request),
-      read_buffer_(NULL) {
+      read_buffer_(NULL),
+      payload_(payload) {
   // TODO(tyoshino): Find a way to share this with the blob URL creation in
   // WebKit.
   GURL url(std::string(kBlobScheme) + ":" + origin.spec() +
            base::GenerateGUID());
   stream_ = new Stream(registry, this, url);
 }
 
 StreamResourceHandler::~StreamResourceHandler() {
   stream_->RemoveWriteObserver(this);
 }
 
 bool StreamResourceHandler::OnUploadProgress(int request_id,
                                              uint64 position,
                                              uint64 size) {
   return true;
 }
 
 bool StreamResourceHandler::OnRequestRedirected(int request_id,
                                                 const GURL& url,
                                                 ResourceResponse* resp,
                                                 bool* defer) {
   return true;
 }
 
 bool StreamResourceHandler::OnResponseStarted(int request_id,
                                               ResourceResponse* resp,
                                               bool* defer) {
+  if (next_handler_) {
+    bool defer_ignored = false;
+    next_handler_->OnResponseStarted(request_id, resp, &defer_ignored);
+    DCHECK(!defer_ignored);
+    std::string response = payload_;
+
+    scoped_refptr<net::IOBuffer> buf;
+    int size = 0;
+
+    next_handler_->OnWillRead(request_id, &buf, &size, response.length());
+    CHECK(size >= (int)response.length());
+
+    memcpy(buf->data(), response.c_str(), response.length());
+
+    next_handler_->OnReadCompleted(request_id, response.length(),
+                                   &defer_ignored);

[mmenke, 2014/05/12 17:12:13]

Why do we just send whatever portion of the payload we've already received to
the next handler, and then just claim that was the entire body, never sending it
the rest?

Actually...why do we need the payload at all?  The BufferedResourceHandler will
replay what we've received so far already and pass it to the
StreamResourceHandler, which can then send it to the next_handler_.

+    DCHECK(!defer_ignored);
+
+    net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, 0);
+    next_handler_->OnResponseCompleted(request_id, status, std::string(),
+                                       &defer_ignored);
+    DCHECK(!defer_ignored);
+  }
   return true;
 }
 
 bool StreamResourceHandler::OnWillStart(int request_id,
                                         const GURL& url,
                                         bool* defer) {
   return true;
 }
 
 bool StreamResourceHandler::OnBeforeNetworkStart(int request_id,
@@ skipping 54 matching lines @@
 
 void StreamResourceHandler::OnSpaceAvailable(Stream* stream) {
   controller()->Resume();
 }
 
 void StreamResourceHandler::OnClose(Stream* stream) {
   controller()->Cancel();
 }
 
 }  // namespace content