Moved NavigationManagerImpl serialization out of CRWSessionController.

ios/web/web_state/web_state_impl.mm

 // Copyright 2013 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 "ios/web/web_state/web_state_impl.h"
 
 #include "base/strings/sys_string_conversions.h"
 #include "ios/web/interstitials/web_interstitial_impl.h"
 #import "ios/web/navigation/crw_session_controller.h"
 #import "ios/web/navigation/crw_session_entry.h"
@@ skipping 10 matching lines @@
 #import "ios/web/web_state/ui/crw_web_controller.h"
 #import "ios/web/web_state/ui/crw_web_controller_container_view.h"
 #include "ios/web/web_state/web_state_facade_delegate.h"
 #import "ios/web/webui/web_ui_ios_controller_factory_registry.h"
 #import "ios/web/webui/web_ui_ios_impl.h"
 #include "net/http/http_response_headers.h"
 
 namespace web {
 
 WebStateImpl::WebStateImpl(BrowserState* browser_state)
+    : WebStateImpl(browser_state, nullptr) {}
+
+WebStateImpl::WebStateImpl(BrowserState* browser_state,
+                           scoped_ptr<NavigationManagerImpl> navigation_manager)
     : is_loading_(false),
       facade_delegate_(nullptr),
       web_controller_(nil),
-      navigation_manager_(this, browser_state),
+      navigation_manager_(navigation_manager.Pass()),
       interstitial_(nullptr),
       cache_mode_(net::RequestTracker::CACHE_NORMAL) {
+  if (!navigation_manager_)
+    navigation_manager_.reset(new NavigationManagerImpl());
+  navigation_manager_->SetDelegate(this);
+  navigation_manager_->SetBrowserState(browser_state);
 }
 
 WebStateImpl::~WebStateImpl() {
   // WebUI depends on web state so it must be destroyed first in case any WebUI
   // implementations depends on accessing web state during destruction.
   ClearWebUI();
 
   // The facade layer (owned by the delegate) should be destroyed before the web
   // layer.
   DCHECK(!facade_delegate_);
@@ skipping 44 matching lines @@
 }
 
 WebStateFacadeDelegate* WebStateImpl::GetFacadeDelegate() const {
   return facade_delegate_;
 }
 
 void WebStateImpl::SetFacadeDelegate(WebStateFacadeDelegate* facade_delegate) {
   facade_delegate_ = facade_delegate;
 }
 
-WebStateImpl* WebStateImpl::CopyForSessionWindow() {
-  WebStateImpl* copy = new WebStateImpl(GetBrowserState());
-  copy->GetNavigationManagerImpl().CopyState(&navigation_manager_);
-  return copy;
+scoped_ptr<WebStateImpl> WebStateImpl::CopyForSerialization() const {
+  return scoped_ptr<WebStateImpl>(new WebStateImpl(
+      GetBrowserState(), navigation_manager_->CopyForSerialization()));
 }
 
 void WebStateImpl::OnUrlHashChanged() {
   FOR_EACH_OBSERVER(WebStateObserver, observers_, UrlHashChanged());
 }
 
 void WebStateImpl::OnHistoryStateChanged() {
   FOR_EACH_OBSERVER(WebStateObserver, observers_, HistoryStateChanged());
 }
 
@@ skipping 102 matching lines @@
                     SignInFailed(request_id, source_url));
 }
 
 void WebStateImpl::OnDocumentSubmitted(const std::string& form_name,
                                        bool user_initiated) {
   FOR_EACH_OBSERVER(WebStateObserver, observers_,
                     DocumentSubmitted(form_name, user_initiated));
 }
 
 NavigationManagerImpl& WebStateImpl::GetNavigationManagerImpl() {
-  return navigation_manager_;
+  return *navigation_manager_;
 }
 
 const NavigationManagerImpl& WebStateImpl::GetNavigationManagerImpl() const {
-  return navigation_manager_;
+  return *navigation_manager_;
 }
 
 // There are currently two kinds of WebUI: those that have been adapted to
 // web::WebUIIOS, and those that are still using content::WebUI. Try to create
 // it as the first, and then fall back to the latter if necessary.
 void WebStateImpl::CreateWebUI(const GURL& url) {
   web_ui_.reset(CreateWebUIIOS(url));
   if (!web_ui_ && facade_delegate_)
     facade_delegate_->CreateLegacyWebUI(url);
 }
@@ skipping 22 matching lines @@
 void WebStateImpl::LoadWebUIHtml(const base::string16& html, const GURL& url) {
   CHECK(web::GetWebClient()->IsAppSpecificURL(url));
   [web_controller_ loadHTML:base::SysUTF16ToNSString(html)
           forAppSpecificURL:url];
 }
 
 const base::string16& WebStateImpl::GetTitle() const {
   // TODO(stuartmorgan): Implement the NavigationManager logic necessary to
   // match the WebContents implementation of this method.
   DCHECK(Configured());
-  web::NavigationItem* item = navigation_manager_.GetLastCommittedItem();
+  web::NavigationItem* item = navigation_manager_->GetLastCommittedItem();
   if (item) {
     return item->GetTitleForDisplay(
         web::GetWebClient()->GetAcceptLangs(GetBrowserState()));
   }
   return empty_string16_;
 }
 
 void WebStateImpl::ShowTransientContentView(CRWContentView* content_view) {
   DCHECK(Configured());
   DCHECK(content_view);
@@ skipping 60 matching lines @@
 void WebStateImpl::ShowWebInterstitial(WebInterstitialImpl* interstitial) {
   DCHECK(Configured());
   DCHECK(interstitial);
   interstitial_ = interstitial;
   ShowTransientContentView(interstitial_->GetContentView());
 }
 
 void WebStateImpl::ClearTransientContentView() {
   if (interstitial_) {
     CRWSessionController* sessionController =
-        navigation_manager_.GetSessionController();
+        navigation_manager_->GetSessionController();
     web::NavigationItem* currentItem =
         [sessionController.currentEntry navigationItem];
     if (currentItem->IsUnsafe()) {
       // The unsafe page or page with bad SSL cert should be removed from the
       // history, and, in fact, Safe Browsing and SSL interstitials will do
       // just that *provided* that it isn't the current page.
       // So to make this happen, before removing the interstitial, have the
       // session controller go back one page.
       [sessionController goBack];
     }
@@ skipping 51 matching lines @@
     if (!policy_decider->ShouldAllowResponse(response))
       return false;
   }
   return true;
 }
 
 #pragma mark - RequestTracker management
 
 void WebStateImpl::InitializeRequestTracker(
     id<CRWRequestTrackerDelegate> delegate) {
-  BrowserState* browser_state = navigation_manager_.GetBrowserState();
+  BrowserState* browser_state = navigation_manager_->GetBrowserState();
   request_tracker_ = RequestTrackerImpl::CreateTrackerForRequestGroupID(
       GetRequestGroupID(), browser_state, browser_state->GetRequestContext(),
       delegate);
 }
 
 void WebStateImpl::CloseRequestTracker() {
   request_tracker_->Close();
   request_tracker_ = NULL;
 }
 
@@ skipping 36 matching lines @@
 
 UIView* WebStateImpl::GetView() {
   return [web_controller_ view];
 }
 
 WebViewType WebStateImpl::GetWebViewType() const {
   return [web_controller_ webViewType];
 }
 
 BrowserState* WebStateImpl::GetBrowserState() const {
-  return navigation_manager_.GetBrowserState();
+  return navigation_manager_->GetBrowserState();
 }
 
 void WebStateImpl::OpenURL(const WebState::OpenURLParams& params) {
   DCHECK(Configured());
   ClearTransientContentView();
   [[web_controller_ delegate] openURLWithParams:params];
 }
 
 NavigationManager* WebStateImpl::GetNavigationManager() {
   return &GetNavigationManagerImpl();
 }
 
 CRWJSInjectionReceiver* WebStateImpl::GetJSInjectionReceiver() const {
   return [web_controller_ jsInjectionReceiver];
 }
 
 const std::string& WebStateImpl::GetContentLanguageHeader() const {
   return content_language_header_;
 }
 
 const std::string& WebStateImpl::GetContentsMimeType() const {
   return mime_type_;
 }
 
 bool WebStateImpl::ContentIsHTML() const {
   return [web_controller_ contentIsHTML];
 }
 
 const GURL& WebStateImpl::GetVisibleURL() const {
-  web::NavigationItem* item = navigation_manager_.GetVisibleItem();
+  web::NavigationItem* item = navigation_manager_->GetVisibleItem();
   return item ? item->GetVirtualURL() : GURL::EmptyGURL();
 }
 
 const GURL& WebStateImpl::GetLastCommittedURL() const {
-  web::NavigationItem* item = navigation_manager_.GetLastCommittedItem();
+  web::NavigationItem* item = navigation_manager_->GetLastCommittedItem();
   return item ? item->GetVirtualURL() : GURL::EmptyGURL();
 }
 
 GURL WebStateImpl::GetCurrentURL(URLVerificationTrustLevel* trust_level) const {
   return [web_controller_ currentURLWithTrustLevel:trust_level];
 }
 
 void WebStateImpl::AddScriptCommandCallback(
     const ScriptCommandCallback& callback,
     const std::string& command_prefix) {
@@ skipping 32 matching lines @@
     const LoadCommittedDetails& load_details) {
   FOR_EACH_OBSERVER(WebStateObserver, observers_,
                     NavigationItemCommitted(load_details));
 }
 
 WebState* WebStateImpl::GetWebState() {
   return this;
 }
 
 }  // namespace web