Save favicon during reading list distillation

components/dom_distiller/ios/distiller_page_ios.mm

 // 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/ios/distiller_page_ios.h"
 
 #import <UIKit/UIKit.h>
 
 #include <utility>
 
 #include "base/json/json_reader.h"
 #include "base/logging.h"
 #include "base/mac/foundation_util.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/sys_string_conversions.h"
+#include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
-#include "ios/public/provider/web/web_controller_provider.h"
-#include "ios/public/provider/web/web_controller_provider_factory.h"
+#include "components/favicon/ios/web_favicon_driver.h"
 #include "ios/web/public/browser_state.h"
+#import "ios/web/public/navigation_manager.h"
+#import "ios/web/public/web_state/js/crw_js_injection_manager.h"
+#import "ios/web/public/web_state/js/crw_js_injection_receiver.h"
+#import "ios/web/public/web_state/web_state.h"
 
 namespace {
 
 // This is duplicated here from ios/web/web_state/ui/web_view_js_utils.mm in
 // order to handle numbers. The dom distiller proto expects integers and the
 // generated JSON deserializer does not accept doubles in the place of ints.
 // However WKWebView only returns "numbers." However, here the proto expects
 // integers and doubles, which is done by checking if the number has a fraction
 // or not; since this is a hacky method it's isolated to this file so as to
 // limit the risk of broken JS calls.
@@ skipping 68 matching lines @@
 
 // Helper class for observing the loading of URLs to distill.
 class DistillerWebStateObserver : public web::WebStateObserver {
  public:
   DistillerWebStateObserver(web::WebState* web_state,
                             DistillerPageIOS* distiller_page);
 
   // WebStateObserver implementation:
   void PageLoaded(
       web::PageLoadCompletionStatus load_completion_status) override;
+  void WebStateDestroyed() override;
 
  private:
   DistillerPageIOS* distiller_page_;  // weak, owns this object.
 };
 
 DistillerWebStateObserver::DistillerWebStateObserver(
     web::WebState* web_state,
     DistillerPageIOS* distiller_page)
     : web::WebStateObserver(web_state), distiller_page_(distiller_page) {
   DCHECK(web_state);
   DCHECK(distiller_page_);
 }
 
 void DistillerWebStateObserver::PageLoaded(
     web::PageLoadCompletionStatus load_completion_status) {
   distiller_page_->OnLoadURLDone(load_completion_status);
 }
 
+void DistillerWebStateObserver::WebStateDestroyed() {
+  distiller_page_->web_state_ = nullptr;
+}
+
 #pragma mark -
 
-DistillerPageIOS::DistillerPageIOS(web::BrowserState* browser_state)
-    : browser_state_(browser_state), weak_ptr_factory_(this) {
-}
+DistillerPageIOS::DistillerPageIOS(
+    FaviconWebStateDispatcher* web_state_dispatcher)
+    : web_state_dispatcher_(web_state_dispatcher), weak_ptr_factory_(this) {}
 
 DistillerPageIOS::~DistillerPageIOS() {
 }
 
 bool DistillerPageIOS::StringifyOutput() {
   return false;
 }
 
 void DistillerPageIOS::DistillPageImpl(const GURL& url,
                                        const std::string& script) {
   if (!url.is_valid() || !script.length())
     return;
   url_ = url;
   script_ = script;
 
-  // Lazily create provider.
-  if (!provider_) {
-    if (ios::GetWebControllerProviderFactory()) {
-      provider_ =
-          ios::GetWebControllerProviderFactory()->CreateWebControllerProvider(
-              browser_state_);
-      web_state_observer_.reset(
-          new DistillerWebStateObserver(provider_->GetWebState(), this));
-    }
+  web_state_ = web_state_dispatcher_->RequestWebState();
+

[sdefresne, 2016/12/20 18:05:31]

nit: I think using early return here could improve readability, but probably
better to do as a followup

  web_state_ = web_state_dispatcher_->RequestWebState();
  if (!web_state_) {
    OnLoadURLDone(web::PageLoadCompletionStatus::FAILURE);
    return;
  }

  web_state_observer_ = base::MakeUnique<DistillerWebStateObserver>(web_state_,
this);
  ...

[gambard, 2016/12/21 08:42:52]

Done.

+  if (web_state_) {
+    web_state_observer_ =
+        base::MakeUnique<DistillerWebStateObserver>(web_state_, this);
+
+    // The favicon driver needs to know which URL is currently fetched.
+    favicon::WebFaviconDriver* favicon_driver =
+        favicon::WebFaviconDriver::FromWebState(web_state_);
+    favicon_driver->FetchFavicon(url_);
+
+    // Load page using WebState.
+    web::NavigationManager::WebLoadParams params(url_);
+    web_state_->SetWebUsageEnabled(true);
+    web_state_->GetNavigationManager()->LoadURLWithParams(params);
+    // GetView is needed because the view is not created (but needed) when
+    // loading the page.
+    web_state_->GetView();
+  } else {
+    OnLoadURLDone(web::PageLoadCompletionStatus::FAILURE);
   }
-
-  // Load page using provider.
-  if (provider_)
-    provider_->LoadURL(url_);
-  else
-    OnLoadURLDone(web::PageLoadCompletionStatus::FAILURE);
 }
 
 void DistillerPageIOS::OnLoadURLDone(
     web::PageLoadCompletionStatus load_completion_status) {
   // Don't attempt to distill if the page load failed or if there is no
-  // provider.
+  // WebState.
   if (load_completion_status == web::PageLoadCompletionStatus::FAILURE ||
-      !provider_) {
+      !web_state_) {
     HandleJavaScriptResult(nil);
     return;
   }
 
   // Inject the script.
   base::WeakPtr<DistillerPageIOS> weak_this = weak_ptr_factory_.GetWeakPtr();
-  provider_->InjectScript(script_, ^(id result, NSError* error) {
-    DistillerPageIOS* distiller_page = weak_this.get();
-    if (distiller_page)
-      distiller_page->HandleJavaScriptResult(result);
-  });
+
+  [[web_state_->GetJSInjectionReceiver()
+      instanceOfClass:[CRWJSInjectionManager class]]
+      executeJavaScript:base::SysUTF8ToNSString(script_)
+      completionHandler:^(id result, NSError* error) {
+        DistillerPageIOS* distiller_page = weak_this.get();
+        if (distiller_page)
+          distiller_page->HandleJavaScriptResult(result);
+      }];
 }
 
 void DistillerPageIOS::HandleJavaScriptResult(id result) {
+  web_state_dispatcher_->ReturnWebState(web_state_);
+  web_state_ = nullptr;
   std::unique_ptr<base::Value> resultValue = base::Value::CreateNullValue();
   if (result) {
     resultValue = ValueResultFromScriptResult(result);
   }
   OnDistillationDone(url_, resultValue.get());
 }
 
 std::unique_ptr<base::Value> DistillerPageIOS::ValueResultFromScriptResult(
     id wk_result) {
   return ::ValueResultFromScriptResult(wk_result,
                                        kMaximumParsingRecursionDepth);
 }
 }  // namespace dom_distiller