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 StartDistillation(content::WebContents* web_contents) {
 114   // Start distillation using |web_contents|, and ensure ViewerHandle stays
 115   // around until the viewer requests distillation.
 116   SelfDeletingRequestDelegate* view_request_delegate =
 117       new SelfDeletingRequestDelegate(web_contents);
 118   scoped_ptr<content::WebContents> old_web_contents_sptr(web_contents);
 119   scoped_ptr<SourcePageHandleWebContents> source_page_handle(
 120       new SourcePageHandleWebContents(old_web_contents_sptr.Pass()));
 121   DomDistillerService* dom_distiller_service =
 122       DomDistillerServiceFactory::GetForBrowserContext(
 123           web_contents->GetBrowserContext());
 124   scoped_ptr<DistillerPage> distiller_page =
 125       dom_distiller_service->CreateDefaultDistillerPageWithHandle(
 126                                  source_page_handle.Pass()).Pass();
 127
 128   const GURL& last_committed_url = web_contents->GetLastCommittedURL();
 129   scoped_ptr<ViewerHandle> viewer_handle = dom_distiller_service->ViewUrl(
 130       view_request_delegate, distiller_page.Pass(), last_committed_url);
 131   view_request_delegate->TakeViewerHandle(viewer_handle.Pass());
 132 }
 133
 134 }  // namespace
 135
 136 void DistillCurrentPageAndView(content::WebContents* old_web_contents) {
 137   DCHECK(old_web_contents);
 138   // Create new WebContents.
 139   content::WebContents::CreateParams create_params(
 140       old_web_contents->GetBrowserContext());
 141   content::WebContents* new_web_contents =
 142       content::WebContents::Create(create_params);
 143   DCHECK(new_web_contents);
 144
 145   // Copy all navigation state from the old WebContents to the new one.
 146   new_web_contents->GetController().CopyStateFrom(
 147       old_web_contents->GetController());
 148
 149   // StartNavigationToDistillerViewer must come before swapping the tab contents
 150   // to avoid triggering a reload of the page.  This reloadmakes it very
 151   // difficult to distinguish between the intermediate reload and a user hitting
 152   // the back button.
 153   StartNavigationToDistillerViewer(new_web_contents,
 154                                    old_web_contents->GetLastCommittedURL());
 155
 156   CoreTabHelper::FromWebContents(old_web_contents)->delegate()->SwapTabContents(
 157       old_web_contents, new_web_contents, false, false);
 158
 159   StartDistillation(old_web_contents);
 160 }