Convert remaining WebContentsObservers loading callbacks to use RFH.

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 37 matching lines @@
       ArticleDistillationUpdate article_update) OVERRIDE;
 
   void TakeViewerHandle(scoped_ptr<ViewerHandle> viewer_handle);
 
   // WebContentsObserver:
   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;
+  virtual void DidFinishLoad(content::RenderFrameHost* render_frame_host,
+                             const GURL& validated_url) OVERRIDE;
 
  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();
 
   // 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_;
 };
 
 DomDistillerViewerSource::RequestViewerHandle::RequestViewerHandle(
     content::WebContents* web_contents,
     const std::string& expected_scheme,
     const std::string& expected_request_path,
     const content::URLDataSource::GotDataCallback& callback)
-    : web_contents_(web_contents),
-      expected_scheme_(expected_scheme),
+    : expected_scheme_(expected_scheme),
       expected_request_path_(expected_request_path),
       callback_(callback),
       page_count_(0),
       waiting_for_page_ready_(true) {
-  content::WebContentsObserver::Observe(web_contents_);
+  content::WebContentsObserver::Observe(web_contents);
 }
 
 DomDistillerViewerSource::RequestViewerHandle::~RequestViewerHandle() {
-  // Balanced with constructor although can be a no-op if frame navigated away.
-  content::WebContentsObserver::Observe(NULL);
 }
 
 void DomDistillerViewerSource::RequestViewerHandle::SendJavaScript(
     const std::string& buffer) {
   if (waiting_for_page_ready_) {
     buffer_ += buffer;
   } else {
-    if (web_contents_) {
-      web_contents_->GetMainFrame()->ExecuteJavaScript(
+    if (web_contents()) {
+      web_contents()->GetMainFrame()->ExecuteJavaScript(
           base::UTF8ToUTF16(buffer));
     }
   }
 }
 
 void DomDistillerViewerSource::RequestViewerHandle::DidNavigateMainFrame(
     const content::LoadCommittedDetails& details,
     const content::FrameNavigateParams& params) {
   const GURL& navigation = details.entry->GetURL();
   if (details.is_in_page || (
@@ skipping 10 matching lines @@
 void DomDistillerViewerSource::RequestViewerHandle::RenderProcessGone(
     base::TerminationStatus status) {
   Cancel();
 }
 
 void DomDistillerViewerSource::RequestViewerHandle::WebContentsDestroyed() {
   Cancel();
 }
 
 void DomDistillerViewerSource::RequestViewerHandle::Cancel() {
-  // Ensure we don't send any incremental updates to the Viewer.
-  web_contents_ = NULL;
-
   // No need to listen for notifications.
   content::WebContentsObserver::Observe(NULL);
 
   // Schedule the Viewer for deletion. Ensures distillation is cancelled, and
   // any pending data stored in |buffer_| is released.
   base::MessageLoop::current()->DeleteSoon(FROM_HERE, this);
 }
 
 void DomDistillerViewerSource::RequestViewerHandle::DidFinishLoad(
-     int64 frame_id,
-     const GURL& validated_url,
-     bool is_main_frame,
-     content::RenderViewHost* render_view_host)  {
-  if (!is_main_frame || web_contents_ == NULL) {
+    content::RenderFrameHost* render_frame_host,
+    const GURL& validated_url) {
+  if (render_frame_host->GetParent()) {
     return;
   }
   waiting_for_page_ready_ = false;
   if (buffer_.empty()) {
     return;
   }
-  if (web_contents_) {
-    web_contents_->GetMainFrame()->ExecuteJavaScript(
-        base::UTF8ToUTF16(buffer_));
-  }
+  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);
     callback_.Run(base::RefCountedString::TakeString(&unsafe_page_html));
   } else if (page_count_ == article_proto->pages_size()) {
@@ skipping 123 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