Show template before distiller finishes

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_request_view_base.h"
 #include "components/dom_distiller/core/dom_distiller_service.h"
 #include "components/dom_distiller/core/external_feedback_reporter.h"
 #include "components/dom_distiller/core/feedback_reporter.h"
 #include "components/dom_distiller/core/task_tracker.h"
 #include "components/dom_distiller/core/url_constants.h"
+#include "components/dom_distiller/core/url_utils.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 "grit/components_strings.h"
 #include "net/base/url_util.h"
 #include "net/url_request/url_request.h"
+#include "ui/base/l10n/l10n_util.h"
 
 namespace dom_distiller {
 
-namespace {
-
-class ContentDataCallback : public DistillerDataCallback {
- public:
-  ContentDataCallback(const content::URLDataSource::GotDataCallback& callback);
-  // Runs the callback.
-  void RunCallback(std::string& data) override;
-
- private:
-  // The callback that actually gets run.
-  content::URLDataSource::GotDataCallback callback_;
-};
-
-ContentDataCallback::ContentDataCallback(
-    const content::URLDataSource::GotDataCallback& callback) {
-  callback_ = callback;
-}
-
-void ContentDataCallback::RunCallback(std::string& data) {
-  callback_.Run(base::RefCountedString::TakeString(&data));
-}
-
-}  // namespace
-
 // 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 DomDistillerRequestViewBase,
       public content::WebContentsObserver {
  public:
   RequestViewerHandle(content::WebContents* web_contents,
                       const std::string& expected_scheme,
                       const std::string& expected_request_path,
-                      scoped_ptr<ContentDataCallback> callback,
                       DistilledPagePrefs* distilled_page_prefs);
   ~RequestViewerHandle() override;
 
   // content::WebContentsObserver implementation:
   void DidNavigateMainFrame(
       const content::LoadCommittedDetails& details,
       const content::FrameNavigateParams& params) override;
   void RenderProcessGone(base::TerminationStatus status) override;
   void WebContentsDestroyed() override;
   void DidFinishLoad(content::RenderFrameHost* render_frame_host,
@@ skipping 21 matching lines @@
 
   // Temporary store of pending JavaScript if the page isn't ready to receive
   // data from distillation.
   std::string buffer_;
 };
 
 DomDistillerViewerSource::RequestViewerHandle::RequestViewerHandle(
     content::WebContents* web_contents,
     const std::string& expected_scheme,
     const std::string& expected_request_path,
-    scoped_ptr<ContentDataCallback> callback,
     DistilledPagePrefs* distilled_page_prefs)
-    : DomDistillerRequestViewBase(callback.Pass(), distilled_page_prefs),
+    : DomDistillerRequestViewBase(distilled_page_prefs),
       expected_scheme_(expected_scheme),
       expected_request_path_(expected_request_path),
       waiting_for_page_ready_(true) {
   content::WebContentsObserver::Observe(web_contents);
   distilled_page_prefs_->AddObserver(this);
 }
 
 DomDistillerViewerSource::RequestViewerHandle::~RequestViewerHandle() {
   distilled_page_prefs_->RemoveObserver(this);
 }
@@ skipping 41 matching lines @@
   // any pending data stored in |buffer_| is released.
   base::MessageLoop::current()->DeleteSoon(FROM_HERE, this);
 }
 
 void DomDistillerViewerSource::RequestViewerHandle::DidFinishLoad(
     content::RenderFrameHost* render_frame_host,
     const GURL& validated_url) {
   if (IsErrorPage()) {
     waiting_for_page_ready_ = false;
     SendJavaScript(viewer::GetErrorPageJs());
+    std::string title(l10n_util::GetStringUTF8(
+        IDS_DOM_DISTILLER_VIEWER_FAILED_TO_FIND_ARTICLE_CONTENT));
+    SendJavaScript(viewer::GetSetTitleJs(title));
+    SendJavaScript(viewer::GetSetTextDirectionJs(std::string("auto")));
     SendJavaScript(viewer::GetShowFeedbackFormJs());
+
     Cancel(); // This will cause the object to clean itself up.
     return;
   }
 
   if (render_frame_host->GetParent()) {
     return;
   }
   waiting_for_page_ready_ = false;
   if (buffer_.empty()) {
     return;
@@ skipping 56 matching lines @@
   } else if (kFeedbackGood == path) {
     FeedbackReporter::ReportQuality(true);
     callback.Run(NULL);
     return;
   }
   content::WebContents* web_contents =
       content::WebContents::FromRenderFrameHost(render_frame_host);
   DCHECK(web_contents);
   // An empty |path| is invalid, but guard against it. If not empty, assume
   // |path| starts with '?', which is stripped away.
-  scoped_ptr<ContentDataCallback> data_callback(
-      new ContentDataCallback(callback));
   const std::string path_after_query_separator =
       path.size() > 0 ? path.substr(1) : "";
-  RequestViewerHandle* request_viewer_handle = new RequestViewerHandle(
-      web_contents, scheme_, path_after_query_separator, data_callback.Pass(),
-      dom_distiller_service_->GetDistilledPagePrefs());
+  RequestViewerHandle* request_viewer_handle =
+      new RequestViewerHandle(web_contents, scheme_, path_after_query_separator,
+                              dom_distiller_service_->GetDistilledPagePrefs());
   scoped_ptr<ViewerHandle> viewer_handle = viewer::CreateViewRequest(
       dom_distiller_service_, path, request_viewer_handle,
       web_contents->GetContainerBounds().size());
 
+  GURL current_url = web_contents->GetLastCommittedURL();
+  std::string unsafe_page_html = viewer::GetUnsafeArticleTemplateHtml(
+      url_utils::GetOriginalUrlFromDistillerUrl(current_url).spec(),
+      dom_distiller_service_->GetDistilledPagePrefs()->GetTheme(),
+      dom_distiller_service_->GetDistilledPagePrefs()->GetFontFamily());
+
   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 {
     request_viewer_handle->FlagAsErrorPage();
   }
+
+  // Place template on the page.
+  callback.Run(base::RefCountedString::TakeString(&unsafe_page_html));
 };
 
 std::string DomDistillerViewerSource::GetMimeType(
     const std::string& path) const {
   if (kViewerCssPath == path) {
     return "text/css";
   }
   if (kViewerJsPath == path) {
     return "text/javascript";
   }
@@ skipping 14 matching lines @@
 std::string DomDistillerViewerSource::GetContentSecurityPolicyObjectSrc()
     const {
   return "object-src 'none'; style-src 'self' https://fonts.googleapis.com;";
 }
 
 std::string DomDistillerViewerSource::GetContentSecurityPolicyFrameSrc() const {
   return "frame-src *;";
 }
 
 }  // namespace dom_distiller