request for pdf resource from the webui

atom/browser/ui/webui/pdf_viewer_handler.cc

@@ -6,6 +6,7 @@
 
 #include "atom/common/atom_constants.h"
 #include "base/bind.h"
+#include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "content/public/browser/stream_handle.h"
 #include "content/public/browser/stream_info.h"
@@ -41,14 +42,35 @@ void CreateResponseHeadersDictionary(const net::HttpResponseHeaders* headers,
   }
 }
 
+void PopulateStreamInfo(base::DictionaryValue* stream_info,
+                        content::StreamInfo* stream,
+                        const std::string& original_url) {
+  std::unique_ptr<base::DictionaryValue> headers_dict(
+      new base::DictionaryValue);
+  auto stream_url = stream->handle->GetURL().spec();
+  CreateResponseHeadersDictionary(stream->response_headers.get(),
+                                  headers_dict.get());
+  stream_info->SetString("streamURL", stream_url);
+  stream_info->SetString("originalURL", original_url);
+  stream_info->Set("responseHeaders", std::move(headers_dict));
+}
+
 }  // namespace
 
-PdfViewerHandler::PdfViewerHandler(const content::StreamInfo* stream,
-                                   const std::string& src)
-    : stream_(stream), original_url_(src) {}
+PdfViewerHandler::PdfViewerHandler(const std::string& src)
+    : stream_(nullptr), original_url_(src), initialized_(false) {}
 
 PdfViewerHandler::~PdfViewerHandler() {}
 
+void PdfViewerHandler::SetPdfResourceStream(content::StreamInfo* stream) {
+  stream_ = stream;
+  if (initialized_) {
+    auto list = base::MakeUnique<base::ListValue>();
+    list->Set(0, std::move(initialize_callback_id_));
+    Initialize(list.get());
+  }
+}
+
 void PdfViewerHandler::RegisterMessages() {
   web_ui()->RegisterMessageCallback(
       "initialize",
@@ -79,24 +101,23 @@ void PdfViewerHandler::OnJavascriptDisallowed() {
 }
 
 void PdfViewerHandler::Initialize(const base::ListValue* args) {
-  AllowJavascript();
-
   CHECK_EQ(1U, args->GetSize());
   const base::Value* callback_id;
   CHECK(args->Get(0, &callback_id));
-  std::unique_ptr<base::DictionaryValue> stream_info(new base::DictionaryValue);
-  std::unique_ptr<base::DictionaryValue> headers_dict(
-      new base::DictionaryValue);
-  std::string stream_url = original_url_;
+
   if (stream_) {
-    stream_url = stream_->handle->GetURL().spec();
-    CreateResponseHeadersDictionary(stream_->response_headers.get(),
-                                    headers_dict.get());
+    initialized_ = false;
+
+    AllowJavascript();
+
+    std::unique_ptr<base::DictionaryValue> stream_info(
+        new base::DictionaryValue);
+    PopulateStreamInfo(stream_info.get(), stream_, original_url_);
+    ResolveJavascriptCallback(*callback_id, *stream_info);
+  } else {
+    initialize_callback_id_ = callback_id->CreateDeepCopy();
+    initialized_ = true;
   }
-  stream_info->SetString("streamURL", stream_url);
-  stream_info->SetString("originalURL", original_url_);
-  stream_info->Set("responseHeaders", std::move(headers_dict));
-  ResolveJavascriptCallback(*callback_id, *stream_info);
 }
 
 void PdfViewerHandler::GetDefaultZoom(const base::ListValue* args) {

atom/browser/ui/webui/pdf_viewer_handler.h

@@ -23,10 +23,12 @@ namespace atom {
 
 class PdfViewerHandler : public content::WebUIMessageHandler {
  public:
-  PdfViewerHandler(const content::StreamInfo* stream,
-                   const std::string& original_url);
+  explicit PdfViewerHandler(const std::string& original_url);
   ~PdfViewerHandler() override;
 
+  void SetPdfResourceStream(content::StreamInfo* stream);
+
+ protected:
   // WebUIMessageHandler implementation.
   void RegisterMessages() override;
   void OnJavascriptAllowed() override;
@@ -43,8 +45,10 @@ class PdfViewerHandler : public content::WebUIMessageHandler {
   // Keeps track of events related to zooming.
   std::unique_ptr<content::HostZoomMap::Subscription>
       host_zoom_map_subscription_;
-  const content::StreamInfo* stream_;
+  std::unique_ptr<base::Value> initialize_callback_id_;
+  content::StreamInfo* stream_;
   std::string original_url_;
+  bool initialized_;
 
   DISALLOW_COPY_AND_ASSIGN(PdfViewerHandler);
 };

atom/browser/ui/webui/pdf_viewer_ui.cc

@@ -11,14 +11,29 @@
 #include "atom/browser/ui/webui/pdf_viewer_handler.h"
 #include "atom/common/atom_constants.h"
 #include "components/pdf/common/pdf_messages.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/resource_context_impl.h"
+#include "content/browser/streams/stream.h"
+#include "content/browser/streams/stream_context.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/render_frame_host.h"
+#include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
+#include "content/public/browser/resource_context.h"
+#include "content/public/browser/stream_handle.h"
 #include "content/public/browser/url_data_source.h"
 #include "content/public/browser/web_contents.h"
-#include "content/public/common/bindings_policy.h"
 #include "grit/pdf_viewer_resources_map.h"
+#include "net/base/load_flags.h"
 #include "net/base/mime_util.h"
+#include "net/url_request/url_request.h"
+#include "net/url_request/url_request_context.h"
 #include "ui/base/resource/resource_bundle.h"
 
+using content::BrowserThread;
+
 namespace atom {
 
 namespace {
@@ -83,19 +98,68 @@ class BundledDataSource : public content::URLDataSource {
   DISALLOW_COPY_AND_ASSIGN(BundledDataSource);
 };
 
+void RequestPdfResource(
+    const GURL& url,
+    const GURL& origin,
+    int render_process_id,
+    int render_view_id,
+    int render_frame_id,
+    content::ResourceContext* resource_context,
+    base::Callback<void(std::unique_ptr<content::StreamInfo>)> callback,
+    atom::LayeredResourceHandler::Delegate* delegate) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  const net::URLRequestContext* request_context =
+      resource_context->GetRequestContext();
+  std::unique_ptr<net::URLRequest> request(
+      request_context->CreateRequest(url, net::DEFAULT_PRIORITY, nullptr));
+  request->set_method("GET");
+
+  content::ResourceDispatcherHostImpl::Get()->InitializeURLRequest(
+      request.get(), content::Referrer(url, blink::WebReferrerPolicyDefault),
+      false,  // download.
+      render_process_id, render_view_id, render_frame_id, resource_context);
+
+  content::ResourceRequestInfoImpl* info =
+      content::ResourceRequestInfoImpl::ForRequest(request.get());
+  content::StreamContext* stream_context =
+      content::GetStreamContextForResourceContext(resource_context);
+
+  std::unique_ptr<content::ResourceHandler> handler(
+      new content::StreamResourceHandler(request.get(),
+                                         stream_context->registry(), origin));
+  info->set_is_stream(true);
+  std::unique_ptr<content::StreamInfo> stream_info(new content::StreamInfo);
+  stream_info->handle =
+      static_cast<content::StreamResourceHandler*>(handler.get())
+          ->stream()
+          ->CreateHandle();
+  stream_info->original_url = request->url();
+
+  // Helper to fill stream response details.
+  handler.reset(new atom::LayeredResourceHandler(request.get(),
+                                                 std::move(handler), delegate));
+
+  content::ResourceDispatcherHostImpl::Get()->BeginURLRequest(
+      std::move(request), std::move(handler),
+      false,  // download
+      false,  // content_initiated (download specific)
+      false,  // do_not_prompt_for_login (download specific)
+      resource_context);
+
+  callback.Run(std::move(stream_info));
+}
+
 }  // namespace
 
 PdfViewerUI::PdfViewerUI(content::BrowserContext* browser_context,
                          content::WebUI* web_ui,
-                         const std::string& stream_id,
                          const std::string& src)
     : content::WebUIController(web_ui),
       content::WebContentsObserver(web_ui->GetWebContents()),
       src_(src) {
-  auto context = static_cast<AtomBrowserContext*>(browser_context);
-  auto stream_manager = context->stream_manager();
-  stream_ = stream_manager->ReleaseStream(stream_id);
-  web_ui->AddMessageHandler(new PdfViewerHandler(stream_.get(), src));
+  pdf_handler_ = new PdfViewerHandler(src);
+  web_ui->AddMessageHandler(pdf_handler_);
   content::URLDataSource::Add(browser_context, new BundledDataSource);
 }
 
@@ -112,6 +176,47 @@ bool PdfViewerUI::OnMessageReceived(
   return handled;
 }
 
+void PdfViewerUI::OnPdfStreamResponseStarted(
+    scoped_refptr<net::HttpResponseHeaders> headers,
+    const std::string& mime_type) {
+  if (headers.get())
+    stream_->response_headers =
+        new net::HttpResponseHeaders(headers->raw_headers());
+  stream_->mime_type = mime_type;
+  pdf_handler_->SetPdfResourceStream(stream_.get());
+}
+
+void PdfViewerUI::OnResponseStarted(content::ResourceResponse* response) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  auto resource_response_head = response->head;
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(&PdfViewerUI::OnPdfStreamResponseStarted,
+                 base::Unretained(this), resource_response_head.headers,
+                 resource_response_head.mime_type));
+}
+
+void PdfViewerUI::OnPdfStreamCreated(
+    std::unique_ptr<content::StreamInfo> stream) {
+  stream_ = std::move(stream);
+}
+
+void PdfViewerUI::RenderFrameCreated(content::RenderFrameHost* rfh) {
+  int render_process_id = rfh->GetProcess()->GetID();
+  int render_frame_id = rfh->GetRoutingID();
+  int render_view_id = rfh->GetRenderViewHost()->GetRoutingID();
+  auto resource_context =
+      web_contents()->GetBrowserContext()->GetResourceContext();
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(
+          &RequestPdfResource, GURL(src_), GURL(kPdfViewerUIOrigin),
+          render_process_id, render_view_id, render_frame_id, resource_context,
+          base::Bind(&PdfViewerUI::OnPdfStreamCreated, base::Unretained(this)),
+          this));
+}
+
 void PdfViewerUI::OnSaveURLAs(const GURL& url,
                               const content::Referrer& referrer) {
   web_contents()->SaveFrame(url, referrer);

atom/browser/ui/webui/pdf_viewer_ui.h

@@ -7,6 +7,7 @@
 
 #include <string>
 
+#include "atom/browser/loader/layered_resource_handler.h"
 #include "base/macros.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "content/public/browser/web_ui_controller.h"
@@ -14,29 +15,48 @@
 
 namespace content {
 class BrowserContext;
+class ResourceContext;
 struct StreamInfo;
 }
 
+namespace net {
+class HttpResponseHeaders;
+}
+
 namespace atom {
 
+class PdfViewerHandler;
+
 class PdfViewerUI : public content::WebUIController,
-                    public content::WebContentsObserver {
+                    public content::WebContentsObserver,
+                    public LayeredResourceHandler::Delegate {
  public:
   PdfViewerUI(content::BrowserContext* browser_context,
               content::WebUI* web_ui,
-              const std::string& stream_id,
               const std::string& src);
   ~PdfViewerUI() override;
 
   // content::WebContentsObserver:
   bool OnMessageReceived(const IPC::Message& message,
                          content::RenderFrameHost* render_frame_host) override;
+  void RenderFrameCreated(content::RenderFrameHost* rfh) override;
+
+  // LayeredResourceHandler:
+  void OnResponseStarted(content::ResourceResponse* response) override;
 
  private:
+  void OnPdfStreamCreated(std::unique_ptr<content::StreamInfo> stream_info);
+  void OnPdfStreamResponseStarted(
+      scoped_refptr<net::HttpResponseHeaders> headers,
+      const std::string& mime_type);
   void OnSaveURLAs(const GURL& url, const content::Referrer& referrer);
 
   // Source URL from where the PDF originates.
   std::string src_;
+
+  PdfViewerHandler* pdf_handler_;
+
+  // Pdf Resource stream.
   std::unique_ptr<content::StreamInfo> stream_;
 
   DISALLOW_COPY_AND_ASSIGN(PdfViewerUI);