[dom_distiller] Add support for incremental viewer.

components/dom_distiller/content/dom_distiller_viewer_source.cc

 // Copyright 2014 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 "components/dom_distiller/content/dom_distiller_viewer_source.h"
 
 #include <sstream>
 #include <string>
 #include <vector>
 
 #include "base/memory/ref_counted_memory.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "components/dom_distiller/core/task_tracker.h"
 #include "components/dom_distiller/core/url_constants.h"
 #include "components/dom_distiller/core/viewer.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "net/url_request/url_request.h"
 
 namespace dom_distiller {
 
 // Handles receiving data asynchronously for a specific entry, and passing
 // it along to the data callback for the data source.
 class DomDistillerViewerSource::RequestViewerHandle
     : public ViewRequestDelegate {
  public:
   explicit RequestViewerHandle(
+      int render_process_id,
+      int render_frame_id,
       const content::URLDataSource::GotDataCallback& callback);
   virtual ~RequestViewerHandle();
 
   // ViewRequestDelegate implementation.
   virtual void OnArticleReady(
       const DistilledArticleProto* article_proto) OVERRIDE;
 
   virtual void OnArticleUpdated(
       ArticleDistillationUpdate article_update) OVERRIDE;
 
   void TakeViewerHandle(scoped_ptr<ViewerHandle> viewer_handle);
 
  private:
   // The handle to the view request towards the DomDistillerService. It
   // needs to be kept around to ensure the distillation request finishes.
   scoped_ptr<ViewerHandle> viewer_handle_;
 
+  // Ids associated with the viewer's render process.
+  int render_process_id_;
+  int render_frame_id_;
+
   // This holds the callback to where the data retrieved is sent back.
   content::URLDataSource::GotDataCallback callback_;
+
+  // Number of pages that have been rendered by the viewer.
+  int page_count_;
 };
 
 DomDistillerViewerSource::RequestViewerHandle::RequestViewerHandle(
+    int render_process_id,
+    int render_frame_id,
     const content::URLDataSource::GotDataCallback& callback)
-    : callback_(callback) {
+    : render_process_id_(render_process_id),
+      render_frame_id_(render_frame_id),
+      callback_(callback),
+      page_count_(0) {
 }
 
 DomDistillerViewerSource::RequestViewerHandle::~RequestViewerHandle() {
 }
 
 void DomDistillerViewerSource::RequestViewerHandle::OnArticleReady(
     const DistilledArticleProto* article_proto) {
-  std::string unsafe_page_html = viewer::GetUnsafeHtml(article_proto);
-  callback_.Run(base::RefCountedString::TakeString(&unsafe_page_html));
+  content::RenderFrameHost* render_frame_host =
+      content::RenderFrameHost::FromID(render_process_id_, render_frame_id_);
+  if (page_count_ == 0) {
+    std::string unsafe_page_html = viewer::GetUnsafeArticleHtml(article_proto);

[nyquist, 2014/04/29 23:58:37]

Add a comment. Maybe something like: "This is a single-page article."

[Yaron, 2014/05/07 05:04:29]

Done.

+    callback_.Run(base::RefCountedString::TakeString(&unsafe_page_html));
+  } else if (page_count_ == article_proto->pages_size()) {
+    // We may still be showing the "Loading" indicator.
+    if (render_frame_host) {
+      render_frame_host->ExecuteJavaScript(
+                viewer::GetToggleLoadingIndicatorJs(true));
+    }
+  } else {
+    if (!render_frame_host) {
+      return;
+    }
+    for (;page_count_ < article_proto->pages_size();

[nyquist, 2014/04/29 23:58:37]

Add a comment saying something like: "Got OnArticleReady before all the
incremental updates. Pushing all we got to the renderer. This maybe the case
when the distiller does not provide incremental updates."

[Yaron, 2014/05/07 05:04:29]

Done-ish.

+        page_count_++) {
+      const DistilledPageProto& page = article_proto->pages(page_count_);
+      render_frame_host->ExecuteJavaScript(
+          viewer::GetUnsafeIncrementalDistilledPageJs(
+              &page,
+              page_count_ == article_proto->pages_size()));
+    }
+  }
   base::MessageLoop::current()->DeleteSoon(FROM_HERE, this);
 }
 
 void DomDistillerViewerSource::RequestViewerHandle::OnArticleUpdated(
     ArticleDistillationUpdate article_update) {
-  // TODO(nyquist): Add support for displaying pages incrementally.
+  content::RenderFrameHost* render_frame_host =
+      content::RenderFrameHost::FromID(render_process_id_, render_frame_id_);
+  for (;page_count_ < static_cast<int>(article_update.GetPagesSize());
+       page_count_++) {
+    const DistilledPageProto& page = article_update.GetDistilledPage(page_count_);
+    if (page_count_ == 0) {
+      std::string unsafe_page_html = viewer::GetUnsafePartialArticleHtml(&page);
+      callback_.Run(base::RefCountedString::TakeString(&unsafe_page_html));
+    } else {
+      if (render_frame_host) {
+        render_frame_host->ExecuteJavaScript(
+            viewer::GetUnsafeIncrementalDistilledPageJs(&page, false));
+      }
+    }
+  }
 }
 
 void DomDistillerViewerSource::RequestViewerHandle::TakeViewerHandle(
     scoped_ptr<ViewerHandle> viewer_handle) {
   viewer_handle_ = viewer_handle.Pass();
 }
 
 DomDistillerViewerSource::DomDistillerViewerSource(
     DomDistillerServiceInterface* dom_distiller_service,
     const std::string& scheme)
@@ skipping 17 matching lines @@
   DCHECK(render_frame_host);
   content::RenderViewHost* render_view_host =
       render_frame_host->GetRenderViewHost();
   DCHECK(render_view_host);
   CHECK_EQ(0, render_view_host->GetEnabledBindings());
 
   if (kCssPath == path) {
     std::string css = viewer::GetCss();
     callback.Run(base::RefCountedString::TakeString(&css));
     return;
+  } else if (kViewerJsPath == path) {

[nyquist, 2014/04/29 23:58:37]

I think you also should add JS to the mime type handling?

[Yaron, 2014/05/07 05:04:29]

Done.

+    std::string js = viewer::GetJavaScript();
+    callback.Run(base::RefCountedString::TakeString(&js));
+    return;
   }
 
   RequestViewerHandle* request_viewer_handle =
-      new RequestViewerHandle(callback);
+      new RequestViewerHandle(render_process_id, render_frame_id, callback);
   scoped_ptr<ViewerHandle> viewer_handle = viewer::CreateViewRequest(
       dom_distiller_service_, path, request_viewer_handle);
 
   if (viewer_handle) {
     // The service returned a |ViewerHandle| and guarantees it will call
     // the |RequestViewerHandle|, so passing ownership to it, to ensure the
     // request is not cancelled. The |RequestViewerHandle| will delete itself
     // after receiving the callback.
     request_viewer_handle->TakeViewerHandle(viewer_handle.Pass());
   } else {
@@ skipping 23 matching lines @@
     const net::URLRequest* request,
     std::string* path) const {
 }
 
 std::string DomDistillerViewerSource::GetContentSecurityPolicyObjectSrc()
     const {
   return "object-src 'none'; style-src 'self';";
 }
 
 }  // namespace dom_distiller