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/logging.h"
 #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
+    : 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);
+};
+
+// Handles sending the first page of content after the template has been
+// loaded successfully.
+class WebContentsTemplateObserver
+    : public content::WebContentsObserver,
+      public content::WebContentsUserData<WebContentsTemplateObserver> {
+ public:
+  explicit WebContentsTemplateObserver(content::WebContents* web_contents) {
+    content::WebContentsObserver::Observe(web_contents);
+  }
+
+  // Once the page has finished loading, send the page(s).
+  void DocumentOnLoadCompletedInMainFrame() override {
+    web_contents()->GetMainFrame()->ExecuteJavaScript(
+        base::UTF8ToUTF16(js_page_content_));
+    // First page has been sent, no need to keep observing.
+    content::WebContentsObserver::Observe(NULL);
+  }
+
+  // Set the content that should be loaded immediately after the template.
+  void setInitialContent(const std::string &content) {
+    js_page_content_ = content;
+  }
+
+ private:
+  friend class content::WebContentsUserData<WebContentsErrorObserver>;
+
+  ~WebContentsTemplateObserver() override {
+    content::WebContentsObserver::Observe(NULL);
+  }
+
+  // The JavaScript that puts the initial content in the page template.
+  std::string js_page_content_;
+
+  DISALLOW_COPY_AND_ASSIGN(WebContentsTemplateObserver);
+};
+
+
+}  // 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 56 matching lines @@
   // Interface for accessing preferences for distilled pages.
   DistilledPagePrefs* distilled_page_prefs_;
 
   // Whether the page is sufficiently initialized to handle updates from the
   // distiller.
   bool waiting_for_page_ready_;
 
   // Temporary store of pending JavaScript if the page isn't ready to receive
   // data from distillation.
   std::string buffer_;
+
+  // WebContentsObserver for detecting the load completion of the page template.
+  WebContentsTemplateObserver* template_observer_;
 };
 
 DomDistillerViewerSource::RequestViewerHandle::RequestViewerHandle(
     content::WebContents* web_contents,
     const std::string& expected_scheme,
     const std::string& expected_request_path,
     const content::URLDataSource::GotDataCallback& callback,
     DistilledPagePrefs* distilled_page_prefs)
     : expected_scheme_(expected_scheme),
       expected_request_path_(expected_request_path),
       callback_(callback),
       page_count_(0),
       distilled_page_prefs_(distilled_page_prefs),
       waiting_for_page_ready_(true) {
   content::WebContentsObserver::Observe(web_contents);
   distilled_page_prefs_->AddObserver(this);
+  template_observer_ = new WebContentsTemplateObserver(web_contents);
 }
 
 DomDistillerViewerSource::RequestViewerHandle::~RequestViewerHandle() {
   distilled_page_prefs_->RemoveObserver(this);
 }
 
 void DomDistillerViewerSource::RequestViewerHandle::SendJavaScript(
     const std::string& buffer) {
   if (waiting_for_page_ready_) {
     buffer_ += buffer;
@@ skipping 10 matching lines @@
     const content::FrameNavigateParams& params) {
   const GURL& navigation = details.entry->GetURL();
   if (details.is_in_page || (
       navigation.SchemeIs(expected_scheme_.c_str()) &&
       expected_request_path_ == navigation.query())) {
     // In-page navigations, as well as the main view request can be ignored.
     return;
   }
 
   Cancel();
-
 }
 
 void DomDistillerViewerSource::RequestViewerHandle::RenderProcessGone(
     base::TerminationStatus status) {
   Cancel();
 }
 
 void DomDistillerViewerSource::RequestViewerHandle::WebContentsDestroyed() {
   Cancel();
 }
@@ skipping 17 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());
+    template_observer_->setInitialContent(
+        viewer::GetUnsafeArticleContentJs(article_proto));
+
+    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.
   } 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) {
+      template_observer_->setInitialContent(
+          viewer::GetUnsafeIncrementalDistilledPageJs(&page, false));
+
       // 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 page content to the client.
+      SendJavaScript(viewer::GetUnsafeIncrementalDistilledPageJs(&page, false));

[cjhopman, 2015/03/24 01:45:36]

Isn't it possible now that the second page has it's javascript called before the
first page?

I feel like we should be able to do this with just one observer and delaying all
SendJavaScript() calls (and then just using SendJavaScript as normal for both
the error case and the first page).

[mdjones, 2015/03/24 18:42:52]

Done/See general comment.

     }
   }
 }
 
 void DomDistillerViewerSource::RequestViewerHandle::TakeViewerHandle(
     scoped_ptr<ViewerHandle> viewer_handle) {
   viewer_handle_ = viewer_handle.Pass();
 }
 
 void DomDistillerViewerSource::RequestViewerHandle::OnChangeTheme(
@@ skipping 65 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