chrome/browser/dom_distiller/tab_utils.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/dom_distiller/tab_utils.h"
   6
   7 #include "base/message_loop/message_loop.h"
   8 #include "chrome/browser/dom_distiller/dom_distiller_service_factory.h"
   9 #include "chrome/browser/ui/tab_contents/core_tab_helper.h"
  10 #include "chrome/browser/ui/tab_contents/core_tab_helper_delegate.h"
  11 #include "components/dom_distiller/content/distiller_page_web_contents.h"
  12 #include "components/dom_distiller/core/distiller_page.h"
  13 #include "components/dom_distiller/core/dom_distiller_service.h"
  14 #include "components/dom_distiller/core/task_tracker.h"
  15 #include "components/dom_distiller/core/url_constants.h"
  16 #include "components/dom_distiller/core/url_utils.h"
  17 #include "content/public/browser/browser_context.h"
  18 #include "content/public/browser/navigation_controller.h"
  19 #include "content/public/browser/web_contents.h"
  20 #include "content/public/browser/web_contents_observer.h"
  21
  22 namespace {
  23
  24 using dom_distiller::ViewRequestDelegate;
  25 using dom_distiller::DistilledArticleProto;
  26 using dom_distiller::ArticleDistillationUpdate;
  27 using dom_distiller::ViewerHandle;
  28 using dom_distiller::SourcePageHandleWebContents;
  29 using dom_distiller::DomDistillerService;
  30 using dom_distiller::DomDistillerServiceFactory;
  31 using dom_distiller::DistillerPage;
  32 using dom_distiller::SourcePageHandle;
  33
  34 // An no-op ViewRequestDelegate which holds a ViewerHandle and deletes itself
  35 // after the WebContents navigates or goes away. This class is a band-aid to
  36 // keep a TaskTracker around until the distillation starts from the viewer.
  37 class SelfDeletingRequestDelegate : public ViewRequestDelegate,
  38                                     public content::WebContentsObserver {
  39  public:
  40   explicit SelfDeletingRequestDelegate(content::WebContents* web_contents);
  41   ~SelfDeletingRequestDelegate() override;
  42
  43   // ViewRequestDelegate implementation.
  44   void OnArticleReady(const DistilledArticleProto* article_proto) override;
  45   void OnArticleUpdated(ArticleDistillationUpdate article_update) override;
  46
  47   // content::WebContentsObserver implementation.
  48   void DidNavigateMainFrame(
  49       const content::LoadCommittedDetails& details,
  50       const content::FrameNavigateParams& params) override;
  51   void RenderProcessGone(base::TerminationStatus status) override;
  52   void WebContentsDestroyed() override;
  53
  54   // Takes ownership of the ViewerHandle to keep distillation alive until |this|
  55   // is deleted.
  56   void TakeViewerHandle(scoped_ptr<ViewerHandle> viewer_handle);
  57
  58  private:
  59   // The handle to the view request towards the DomDistillerService. It
  60   // needs to be kept around to ensure the distillation request finishes.
  61   scoped_ptr<ViewerHandle> viewer_handle_;
  62 };
  63
  64 void SelfDeletingRequestDelegate::DidNavigateMainFrame(
  65     const content::LoadCommittedDetails& details,
  66     const content::FrameNavigateParams& params) {
  67   Observe(NULL);
  68   base::MessageLoop::current()->DeleteSoon(FROM_HERE, this);
  69 }
  70
  71 void SelfDeletingRequestDelegate::RenderProcessGone(
  72     base::TerminationStatus status) {
  73   Observe(NULL);
  74   base::MessageLoop::current()->DeleteSoon(FROM_HERE, this);
  75 }
  76
  77 void SelfDeletingRequestDelegate::WebContentsDestroyed() {
  78   Observe(NULL);
  79   base::MessageLoop::current()->DeleteSoon(FROM_HERE, this);
  80 }
  81
  82 SelfDeletingRequestDelegate::SelfDeletingRequestDelegate(
  83     content::WebContents* web_contents)
  84     : WebContentsObserver(web_contents) {
  85 }
  86
  87 SelfDeletingRequestDelegate::~SelfDeletingRequestDelegate() {
  88 }
  89
  90 void SelfDeletingRequestDelegate::OnArticleReady(
  91     const DistilledArticleProto* article_proto) {
  92 }
  93
  94 void SelfDeletingRequestDelegate::OnArticleUpdated(
  95     ArticleDistillationUpdate article_update) {
  96 }
  97
  98 void SelfDeletingRequestDelegate::TakeViewerHandle(
  99     scoped_ptr<ViewerHandle> viewer_handle) {
 100   viewer_handle_ = viewer_handle.Pass();
 101 }
 102
 103 // Start loading the viewer URL of the current page in |web_contents|.
 104 void StartNavigationToDistillerViewer(content::WebContents* web_contents,
 105                                       const GURL& url) {
 106   GURL viewer_url = dom_distiller::url_utils::GetDistillerViewUrlFromUrl(
 107       dom_distiller::kDomDistillerScheme, url);
 108   content::NavigationController::LoadURLParams params(viewer_url);
 109   params.transition_type = ui::PAGE_TRANSITION_AUTO_BOOKMARK;
 110   web_contents->GetController().LoadURLWithParams(params);
 111 }
 112
 113 void MaybeStartDistillation(content::WebContents* web_contents) {
 114   const GURL& last_committed_url = web_contents->GetLastCommittedURL();
 115   if (!dom_distiller::url_utils::IsUrlDistillable(last_committed_url)) {
 116     delete web_contents;
 117     return;
 118   }
 119
 120   // Start distillation using |web_contents|, and ensure ViewerHandle stays
 121   // around until the viewer requests distillation.
 122   SelfDeletingRequestDelegate* view_request_delegate =
 123       new SelfDeletingRequestDelegate(web_contents);
 124   scoped_ptr<content::WebContents> old_web_contents_sptr(web_contents);
 125   scoped_ptr<SourcePageHandleWebContents> source_page_handle(
 126       new SourcePageHandleWebContents(old_web_contents_sptr.Pass()));
 127   DomDistillerService* dom_distiller_service =
 128       DomDistillerServiceFactory::GetForBrowserContext(
 129           web_contents->GetBrowserContext());
 130   scoped_ptr<DistillerPage> distiller_page =
 131       dom_distiller_service->CreateDefaultDistillerPageWithHandle(
 132                                  source_page_handle.Pass()).Pass();
 133
 134   scoped_ptr<ViewerHandle> viewer_handle = dom_distiller_service->ViewUrl(
 135       view_request_delegate, distiller_page.Pass(), last_committed_url);
 136   view_request_delegate->TakeViewerHandle(viewer_handle.Pass());
 137 }
 138
 139 }  // namespace
 140
 141 void DistillCurrentPageAndView(content::WebContents* old_web_contents) {
 142   DCHECK(old_web_contents);
 143   // Create new WebContents.
 144   content::WebContents::CreateParams create_params(
 145       old_web_contents->GetBrowserContext());
 146   content::WebContents* new_web_contents =
 147       content::WebContents::Create(create_params);
 148   DCHECK(new_web_contents);
 149
 150   // Copy all navigation state from the old WebContents to the new one.
 151   new_web_contents->GetController().CopyStateFrom(
 152       old_web_contents->GetController());
 153
 154   // StartNavigationToDistillerViewer must come before swapping the tab contents
 155   // to avoid triggering a reload of the page.  This reloadmakes it very
 156   // difficult to distinguish between the intermediate reload and a user hitting
 157   // the back button.
 158   StartNavigationToDistillerViewer(new_web_contents,
 159                                    old_web_contents->GetLastCommittedURL());
 160
 161   CoreTabHelper::FromWebContents(old_web_contents)->delegate()->SwapTabContents(
 162       old_web_contents, new_web_contents, false, false);
 163
 164   MaybeStartDistillation(old_web_contents);
 165 }