Consistent content placement method for dom-distiller

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 "base/metrics/user_metrics.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/dom_distiller/core/distilled_page_prefs.h"
 #include "components/dom_distiller/core/dom_distiller_service.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/navigation_details.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_observer.h"
+#include "content/public/browser/web_contents_user_data.h"
 #include "net/base/url_util.h"
 #include "net/url_request/url_request.h"
 
+namespace {
+
+// Handles sending conent to pages that are in an error state (i.e. the URL
+// was bad or could not be loaded).
+class WebContentsErrorObserver

[cjhopman, 2015/03/21 02:33:22]

If distillation returned really really fast, could a successful distillation run
into the same case of calling javascript too early?

[mdjones, 2015/03/24 01:32:42]

Yes, I have added a second observer to watch for the template to be loaded on
the page. This places the first page of content then stops observing.

+    : public content::WebContentsObserver,
+      public content::WebContentsUserData<WebContentsErrorObserver> {
+ public:
+  // Once the page has finished loading, send an error message.
+  void DocumentOnLoadCompletedInMainFrame() override {
+    web_contents()->GetMainFrame()->ExecuteJavaScript(
+        base::UTF8ToUTF16(dom_distiller::viewer::GetErrorPageJs()));
+  }
+
+ private:
+  friend class content::WebContentsUserData<WebContentsErrorObserver>;
+  explicit WebContentsErrorObserver(content::WebContents* web_contents)
+      : WebContentsObserver(web_contents) {}
+
+  ~WebContentsErrorObserver() override {
+    content::WebContentsObserver::Observe(NULL);
+  }
+
+  DISALLOW_COPY_AND_ASSIGN(WebContentsErrorObserver);
+};
+
+}  // namespace
+
+DEFINE_WEB_CONTENTS_USER_DATA_KEY(WebContentsErrorObserver);
+
 namespace dom_distiller {
 
 // Handles receiving data asynchronously for a specific entry, and passing
 // it along to the data callback for the data source. Lifetime matches that of
 // the current main frame's page in the Viewer instance.
 class DomDistillerViewerSource::RequestViewerHandle
     : public ViewRequestDelegate,
       public content::WebContentsObserver,
       public DistilledPagePrefs::Observer {
  public:
@@ skipping 140 matching lines @@
   if (buffer_.empty()) {
     return;
   }
   web_contents()->GetMainFrame()->ExecuteJavaScript(base::UTF8ToUTF16(buffer_));
   buffer_.clear();
 }
 
 void DomDistillerViewerSource::RequestViewerHandle::OnArticleReady(
     const DistilledArticleProto* article_proto) {
   if (page_count_ == 0) {
-    // This is a single-page article.
-    std::string unsafe_page_html =
-        viewer::GetUnsafeArticleHtml(
-            article_proto,
-            distilled_page_prefs_->GetTheme(),
-            distilled_page_prefs_->GetFontFamily());
+    std::string unsafe_page_html = viewer::GetUnsafeArticleTemplateHtml(
+        &article_proto->pages(0),
+        distilled_page_prefs_->GetTheme(),
+        distilled_page_prefs_->GetFontFamily());
     callback_.Run(base::RefCountedString::TakeString(&unsafe_page_html));
+
+    // Send the actual article content to the page.
+    SendJavaScript(viewer::GetUnsafeArticleContentJs(article_proto));
   } else if (page_count_ == article_proto->pages_size()) {
     // We may still be showing the "Loading" indicator.
     SendJavaScript(viewer::GetToggleLoadingIndicatorJs(true));
   } else {
     // It's possible that we didn't get some incremental updates from the
     // distiller. Ensure all remaining pages are flushed to the viewer.
     for (;page_count_ < article_proto->pages_size(); page_count_++) {
       const DistilledPageProto& page = article_proto->pages(page_count_);
       SendJavaScript(
           viewer::GetUnsafeIncrementalDistilledPageJs(
               &page,
               page_count_ == article_proto->pages_size()));
     }
   }
   // No need to hold on to the ViewerHandle now that distillation is complete.
   viewer_handle_.reset();
 }
 
 void DomDistillerViewerSource::RequestViewerHandle::OnArticleUpdated(
     ArticleDistillationUpdate article_update) {
   for (;page_count_ < static_cast<int>(article_update.GetPagesSize());
        page_count_++) {
     const DistilledPageProto& page =
         article_update.GetDistilledPage(page_count_);
     if (page_count_ == 0) {
       // This is the first page, so send Viewer page scaffolding too.
-      std::string unsafe_page_html = viewer::GetUnsafePartialArticleHtml(
+      std::string unsafe_page_html = viewer::GetUnsafeArticleTemplateHtml(
           &page,
           distilled_page_prefs_->GetTheme(),
           distilled_page_prefs_->GetFontFamily());
       callback_.Run(base::RefCountedString::TakeString(&unsafe_page_html));
-    } else {
-      SendJavaScript(
-          viewer::GetUnsafeIncrementalDistilledPageJs(&page, false));
     }
+    // Send the actual article content to the page.
+    SendJavaScript(viewer::GetUnsafeIncrementalDistilledPageJs(&page, false));
   }
 }
 
 void DomDistillerViewerSource::RequestViewerHandle::TakeViewerHandle(
     scoped_ptr<ViewerHandle> viewer_handle) {
   viewer_handle_ = viewer_handle.Pass();
 }
 
 void DomDistillerViewerSource::RequestViewerHandle::OnChangeTheme(
     DistilledPagePrefs::Theme new_theme) {
@@ skipping 64 matching lines @@
     // 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 {
     // The service did not return a |ViewerHandle|, which means the
     // |RequestViewerHandle| will never be called, so clean up now.
     delete request_viewer_handle;
 
+    WebContentsErrorObserver::CreateForWebContents(web_contents);
+
     std::string error_page_html = viewer::GetErrorPageHtml(
         dom_distiller_service_->GetDistilledPagePrefs()->GetTheme(),
         dom_distiller_service_->GetDistilledPagePrefs()->GetFontFamily());
     callback.Run(base::RefCountedString::TakeString(&error_page_html));
   }
 };
 
 std::string DomDistillerViewerSource::GetMimeType(
     const std::string& path) const {
   if (kViewerCssPath == path) {
@@ skipping 15 matching lines @@
     const net::URLRequest* request,
     std::string* path) const {
 }
 
 std::string DomDistillerViewerSource::GetContentSecurityPolicyObjectSrc()
     const {
   return "object-src 'none'; style-src 'self' https://fonts.googleapis.com;";
 }
 
 }  // namespace dom_distiller