Theme Preferences for Distilled Pages

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/strings/utf_string_conversions.h"
+#include "components/dom_distiller/core/dom_distiller_service.h"
+#include "components/dom_distiller/core/reader_mode_preferences.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/web_contents.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "net/base/url_util.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. Lifetime matches that of
 // the current main frame's page in the Viewer instance.
 class DomDistillerViewerSource::RequestViewerHandle
     : public ViewRequestDelegate,
-      public content::WebContentsObserver {
+      public content::WebContentsObserver,
+      public ReaderModePrefs::Observer {
  public:
   explicit RequestViewerHandle(
       content::WebContents* web_contents,
       const std::string& expected_scheme,
       const std::string& expected_request_path,
-      const content::URLDataSource::GotDataCallback& callback);
+      const content::URLDataSource::GotDataCallback& callback,
+      ReaderModePrefs* reader_mode_prefs);
   virtual ~RequestViewerHandle();
 
-  // ViewRequestDelegate implementation.
+  // ViewRequestDelegate implementation:
   virtual void OnArticleReady(
       const DistilledArticleProto* article_proto) OVERRIDE;
 
   virtual void OnArticleUpdated(
       ArticleDistillationUpdate article_update) OVERRIDE;
 
   void TakeViewerHandle(scoped_ptr<ViewerHandle> viewer_handle);
 
-  // WebContentsObserver:
+  // content::WebContentsObserver implementation:
   virtual void DidNavigateMainFrame(
       const content::LoadCommittedDetails& details,
       const content::FrameNavigateParams& params) OVERRIDE;
   virtual void RenderProcessGone(base::TerminationStatus status) OVERRIDE;
   virtual void WebContentsDestroyed() OVERRIDE;
   virtual void DidFinishLoad(
       int64 frame_id,
       const GURL& validated_url,
       bool is_main_frame,
       content::RenderViewHost* render_view_host) OVERRIDE;
 
+  // Needed by DomDistillerViewerSource.
+  const ReaderModePrefs* GetReaderModePrefs();

[nyquist, 2014/06/27 20:48:26]

Remove.

[smaslo, 2014/06/30 17:57:14]

It removed it, but I had to make the reader_mode_prefs_ variable public so that
the outer class DomDistillerViewerSource has access to it.

+
  private:
   // Sends JavaScript to the attached Viewer, buffering data if the viewer isn't
   // ready.
   void SendJavaScript(const std::string& buffer);
 
   // Cancels the current view request. Once called, no updates will be
   // propagated to the view, and the request to DomDistillerService will be
   // cancelled.
   void Cancel();
 
+  // ReaderModePrefs::Observer implementation:
+  virtual void OnChangeTheme(ReaderModePrefs::Theme new_theme) OVERRIDE;
+
+  // Sets CSS class name for the webpage's HTML body element.

[nyquist, 2014/06/27 20:48:26]

Remove

[smaslo, 2014/06/30 17:57:14]

Done.

+  void SetBodyClassName();
+
   // 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_;
 
   // WebContents associated with the Viewer's render process.
   content::WebContents* web_contents_;
 
   // The scheme hosting the current view request;
   std::string expected_scheme_;
 
   // The query path for the current view request.
   std::string expected_request_path_;
 
   // Holds the callback to where the data retrieved is sent back.
   content::URLDataSource::GotDataCallback callback_;
 
   // Number of pages of the distilled article content that have been rendered by
   // the viewer.
   int page_count_;
 
   // 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_;
+
+  // Interface for accessing preferences for reader mode.
+  ReaderModePrefs* reader_mode_prefs_;
 };
 
 DomDistillerViewerSource::RequestViewerHandle::RequestViewerHandle(
     content::WebContents* web_contents,
     const std::string& expected_scheme,
     const std::string& expected_request_path,
-    const content::URLDataSource::GotDataCallback& callback)
+    const content::URLDataSource::GotDataCallback& callback,
+    ReaderModePrefs* reader_mode_prefs)
     : web_contents_(web_contents),
       expected_scheme_(expected_scheme),
       expected_request_path_(expected_request_path),
       callback_(callback),
       page_count_(0),
-      waiting_for_page_ready_(true) {
+      waiting_for_page_ready_(true),
+      reader_mode_prefs_(reader_mode_prefs) {
   content::WebContentsObserver::Observe(web_contents_);
+  reader_mode_prefs_->AddObserver(this);
 }
 
 DomDistillerViewerSource::RequestViewerHandle::~RequestViewerHandle() {
   // Balanced with constructor although can be a no-op if frame navigated away.
   content::WebContentsObserver::Observe(NULL);
+  reader_mode_prefs_->RemoveObserver(this);
 }
 
 void DomDistillerViewerSource::RequestViewerHandle::SendJavaScript(
     const std::string& buffer) {
   if (waiting_for_page_ready_) {
     buffer_ += buffer;
   } else {
     if (web_contents_) {
       web_contents_->GetMainFrame()->ExecuteJavaScript(
           base::UTF8ToUTF16(buffer));
@@ skipping 53 matching lines @@
     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);
+    std::string unsafe_page_html = viewer::GetUnsafeArticleHtml(article_proto,
+        reader_mode_prefs_->GetThemePref());
     callback_.Run(base::RefCountedString::TakeString(&unsafe_page_html));
   } 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(&page);
+      std::string unsafe_page_html = viewer::GetUnsafePartialArticleHtml(&page,
+          reader_mode_prefs_->GetThemePref());
       callback_.Run(base::RefCountedString::TakeString(&unsafe_page_html));
     } else {
       SendJavaScript(
           viewer::GetUnsafeIncrementalDistilledPageJs(&page, false));
     }
   }
 }
 
 void DomDistillerViewerSource::RequestViewerHandle::TakeViewerHandle(
     scoped_ptr<ViewerHandle> viewer_handle) {
   viewer_handle_ = viewer_handle.Pass();
 }
 
+void DomDistillerViewerSource::RequestViewerHandle::OnChangeTheme(
+    ReaderModePrefs::Theme theme) {

[nyquist, 2014/06/27 20:48:26]

Nit: new_theme

[smaslo, 2014/06/30 17:57:14]

Done.

+  SetBodyClassName();

[nyquist, 2014/06/27 20:48:26]

This is the only place that method is used, so just inline it here.

[smaslo, 2014/06/30 17:57:14]

Done.

+}
+
+void DomDistillerViewerSource::RequestViewerHandle::SetBodyClassName() {

[nyquist, 2014/06/27 20:48:26]

Require theme as argument:
ReaderModePrefs::Theme theme
Then use that in the string stream

[smaslo, 2014/06/30 17:57:14]

Done.

+  std::ostringstream js;
+  js << "document.body.className='" <<
+    viewer::GetBodyCssClass(reader_mode_prefs_->GetThemePref()) << "';";
+  SendJavaScript(js.str());
+}
+
+const ReaderModePrefs* DomDistillerViewerSource::RequestViewerHandle::

[nyquist, 2014/06/27 20:48:26]

Remove.

[smaslo, 2014/06/30 17:57:14]

Done.

+    GetReaderModePrefs() {
+  return reader_mode_prefs_;
+}
+
 DomDistillerViewerSource::DomDistillerViewerSource(
     DomDistillerServiceInterface* dom_distiller_service,
     const std::string& scheme)
     : scheme_(scheme), dom_distiller_service_(dom_distiller_service) {
 }
 
 DomDistillerViewerSource::~DomDistillerViewerSource() {
 }
 
 std::string DomDistillerViewerSource::GetSource() const {
@@ skipping 26 matching lines @@
   content::WebContents* web_contents =
       content::WebContents::FromRenderFrameHost(
           content::RenderFrameHost::FromID(render_process_id,
                                            render_frame_id));
   DCHECK(web_contents);
   // An empty |path| is invalid, but guard against it. If not empty, assume
   // |path| starts with '?', which is stripped away.
   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, callback);
+      web_contents, scheme_, path_after_query_separator, callback,
+      dom_distiller_service_->GetReaderModePrefs());
   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 {
+    std::string error_page_html = viewer::GetErrorPageHtml(
+        request_viewer_handle->GetReaderModePrefs()->GetThemePref());
     // The service did not return a |ViewerHandle|, which means the

[nyquist, 2014/06/27 20:48:26]

Just get it from the service like you do above. That way you don't have to add
the accessor method.
Then move this code down to where it was before. 

[smaslo, 2014/06/30 17:57:14]

Done.

     // |RequestViewerHandle| will never be called, so clean up now.
     delete request_viewer_handle;
-
-    std::string error_page_html = viewer::GetErrorPageHtml();
     callback.Run(base::RefCountedString::TakeString(&error_page_html));
   }
 };
 
 std::string DomDistillerViewerSource::GetMimeType(
     const std::string& path) const {
   if (kViewerCssPath == path) {
     return "text/css";
   }
   if (kViewerJsPath == path) {
@@ skipping 12 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