Font Family 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>
 
@@ skipping 55 matching lines @@
   // 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();
 
   // DistilledPagePrefs::Observer implementation:
+  virtual void OnChangeFontFamily(
+      DistilledPagePrefs::FontFamily new_font_family) OVERRIDE;
   virtual void OnChangeTheme(DistilledPagePrefs::Theme new_theme) OVERRIDE;
 
   // 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_;
 
   // The scheme hosting the current view request;
   std::string expected_scheme_;
 
   // The query path for the current view request.
@@ skipping 94 matching lines @@
     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());
+    std::string unsafe_page_html =
+        viewer::GetUnsafeArticleHtml(article_proto,

[robliao, 2014/08/10 02:43:45]

Consistency: Wrap these arguments to the next line.

[sunangel, 2014/08/11 21:51:33]

Can you explain what you mean? Git cl format turned it into this.
On 2014/08/10 02:43:45, robliao wrote:

[robliao, 2014/08/11 22:00:45]

Look at GetUnsafePartialArticleHtml below. Use that style.

[sunangel, 2014/08/12 02:09:55]

Done.

+                                     distilled_page_prefs_->GetTheme(),
+                                     distilled_page_prefs_->GetFontFamily());
     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, distilled_page_prefs_->GetTheme());
+          &page,
+          distilled_page_prefs_->GetTheme(),
+          distilled_page_prefs_->GetFontFamily());
       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(
     DistilledPagePrefs::Theme new_theme) {
   SendJavaScript(viewer::GetDistilledPageThemeJs(new_theme));
 }
 
+void DomDistillerViewerSource::RequestViewerHandle::OnChangeFontFamily(
+    DistilledPagePrefs::FontFamily new_font) {
+  SendJavaScript(viewer::GetDistilledPageFontFamilyJs(new_font));
+}
+
 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 44 matching lines @@
     // 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;
 
     std::string error_page_html = viewer::GetErrorPageHtml(
-        dom_distiller_service_->GetDistilledPagePrefs()->GetTheme());
+        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) {
     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