Create a NavigationEntry for the initial blank page.

content/browser/frame_host/navigation_controller_impl.cc

 // 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.
 
 /*
  * Copyright (C) 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved.
  *     (http://www.torchmobile.com/)
  *
@@ skipping 205 matching lines @@
   // Otherwise, we're clear of the last duplicate run, so reset the
   // water marks.
   low_water_mark_ = high_water_mark_ = t;
   return t;
 }
 
 NavigationControllerImpl::NavigationControllerImpl(
     NavigationControllerDelegate* delegate,
     BrowserContext* browser_context)
     : browser_context_(browser_context),
-      pending_entry_(NULL),
+      pending_entry_(nullptr),
       failed_pending_entry_id_(0),
       failed_pending_entry_should_replace_(false),
-      last_committed_entry_index_(-1),
+      last_committed_entry_index_(0),
       pending_entry_index_(-1),
       transient_entry_index_(-1),
       delegate_(delegate),
       max_restored_page_id_(-1),
       ssl_manager_(this),
       needs_reload_(false),
       is_initial_navigation_(true),
       in_navigate_to_pending_entry_(false),
       pending_reload_(NO_RELOAD),
       get_timestamp_callback_(base::Bind(&base::Time::Now)),
@@ skipping 16 matching lines @@
 void NavigationControllerImpl::SetBrowserContext(
     BrowserContext* browser_context) {
   browser_context_ = browser_context;
 }
 
 void NavigationControllerImpl::Restore(
     int selected_navigation,
     RestoreType type,
     ScopedVector<NavigationEntry>* entries) {
   // Verify that this controller is unused and that the input is valid.
-  DCHECK(GetEntryCount() == 0 && !GetPendingEntry());
+  DCHECK(IsInitialBlankNavigation() && GetEntryCount() == 1 &&
+         !GetPendingEntry());
   DCHECK(selected_navigation >= 0 &&
          selected_navigation < static_cast<int>(entries->size()));
 
   needs_reload_ = true;
+  entries_.clear();
   for (size_t i = 0; i < entries->size(); ++i) {
     NavigationEntryImpl* entry =
         NavigationEntryImpl::FromNavigationEntry((*entries)[i]);
     entries_.push_back(entry);
   }
   entries->weak_clear();
 
   // And finish the restore.
   FinishRestore(selected_navigation, type);
 }
@@ skipping 114 matching lines @@
   } else {
     ReloadInternal(false, pending_reload_);
     pending_reload_ = NO_RELOAD;
   }
 }
 
 bool NavigationControllerImpl::IsInitialNavigation() const {
   return is_initial_navigation_;
 }
 
+bool NavigationControllerImpl::IsInitialBlankNavigation() const {
+  // Only return true if the initial navigation is not marked as a restore, as
+  // it is during a clone.
+  return IsInitialNavigation() &&
+      GetEntryCount() == 1 &&
+      GetEntryAtIndex(0)->restore_type() == NavigationEntryImpl::RESTORE_NONE;
+}
+
 NavigationEntryImpl* NavigationControllerImpl::GetEntryWithPageID(
   SiteInstance* instance, int32 page_id) const {
   int index = GetEntryIndexWithPageID(instance, page_id);
   return (index != -1) ? entries_[index] : nullptr;
 }
 
 NavigationEntryImpl*
 NavigationControllerImpl::GetEntryWithUniqueID(int nav_entry_id) const {
   int index = GetEntryIndexWithUniqueID(nav_entry_id);
   return (index != -1) ? entries_[index] : nullptr;
@@ skipping 61 matching lines @@
 
 int NavigationControllerImpl::GetCurrentEntryIndex() const {
   if (transient_entry_index_ != -1)
     return transient_entry_index_;
   if (pending_entry_index_ != -1)
     return pending_entry_index_;
   return last_committed_entry_index_;
 }
 
 NavigationEntryImpl* NavigationControllerImpl::GetLastCommittedEntry() const {
-  if (last_committed_entry_index_ == -1)
-    return NULL;
+  DCHECK_GE(last_committed_entry_index_, 0);
+  DCHECK_LT(last_committed_entry_index_, GetEntryCount());
   return entries_[last_committed_entry_index_];
 }
 
 bool NavigationControllerImpl::CanViewSource() const {
   const std::string& mime_type = delegate_->GetContentsMimeType();
   bool is_viewable_mime_type =
       mime_util::IsSupportedNonImageMimeType(mime_type) &&
       !media::IsSupportedMediaMimeType(mime_type);
   NavigationEntry* visible_entry = GetVisibleEntry();
   return visible_entry && !visible_entry->IsViewSourceMode() &&
@@ skipping 287 matching lines @@
       break;
   };
 
   LoadEntry(entry.Pass());
 }
 
 bool NavigationControllerImpl::RendererDidNavigate(
     RenderFrameHostImpl* rfh,
     const FrameHostMsg_DidCommitProvisionalLoad_Params& params,
     LoadCommittedDetails* details) {
-  is_initial_navigation_ = false;
-
   // Save the previous state before we clobber it.
   if (GetLastCommittedEntry()) {
     details->previous_url = GetLastCommittedEntry()->GetURL();
     details->previous_entry_index = GetLastCommittedEntryIndex();
   } else {
     details->previous_url = GURL();
     details->previous_entry_index = -1;
   }
 
   // If there is a pending entry at this point, it should have a SiteInstance,
@@ skipping 13 matching lines @@
   // If this is an error load, we may have already removed the pending entry
   // when we got the notice of the load failure. If so, look at the copy of the
   // pending parameters that were saved.
   if (params.url_is_unreachable && failed_pending_entry_id_ != 0) {
     details->did_replace_entry = failed_pending_entry_should_replace_;
   } else {
     details->did_replace_entry = pending_entry_ &&
                                  pending_entry_->should_replace_entry();
   }
 
+  // If this is the first navigation after the initial about:blank page, then it
+  // should replace the initial NavigationEntry, regardless of the checks above.
+  if (IsInitialBlankNavigation())
+    details->did_replace_entry = true;
+  is_initial_navigation_ = false;
+
   // Do navigation-type specific actions. These will make and commit an entry.
   details->type = ClassifyNavigation(rfh, params);
 
   // is_in_page must be computed before the entry gets committed.
   details->is_in_page = IsURLInPageNavigation(
       params.url, params.was_within_same_page, rfh);
 
   switch (details->type) {
     case NAVIGATION_TYPE_NEW_PAGE:
       RendererDidNavigateToNewPage(rfh, params, details->did_replace_entry);
       break;
     case NAVIGATION_TYPE_EXISTING_PAGE:
+      // TODO(creis): This is wrong.  See
+      // https://codereview.chromium.org/1214073005.  Shouldn't touch this value
+      // in most cases.
       details->did_replace_entry = details->is_in_page;
       RendererDidNavigateToExistingPage(rfh, params);
       break;
     case NAVIGATION_TYPE_SAME_PAGE:
       RendererDidNavigateToSamePage(rfh, params);
       break;
     case NAVIGATION_TYPE_NEW_SUBFRAME:
       RendererDidNavigateNewSubframe(rfh, params);
       break;
     case NAVIGATION_TYPE_AUTO_SUBFRAME:
       if (!RendererDidNavigateAutoSubframe(rfh, params))
         return false;
       break;
-    case NAVIGATION_TYPE_NAV_IGNORE:
-      // If a pending navigation was in progress, this canceled it.  We should
-      // discard it and make sure it is removed from the URL bar.  After that,
-      // there is nothing we can do with this navigation, so we just return to
-      // the caller that nothing has happened.
-      if (pending_entry_) {
-        DiscardNonCommittedEntries();
-        delegate_->NotifyNavigationStateChanged(INVALIDATE_TYPE_URL);
-      }
-      return false;
     default:
       NOTREACHED();
   }
 
   // At this point, we know that the navigation has just completed, so
   // record the time.
   //
   // TODO(akalin): Use "sane time" as described in
   // http://www.chromium.org/developers/design-documents/sane-time .
   base::Time timestamp =
@@ skipping 71 matching lines @@
 
   return true;
 }
 
 NavigationType NavigationControllerImpl::ClassifyNavigation(
     RenderFrameHostImpl* rfh,
     const FrameHostMsg_DidCommitProvisionalLoad_Params& params) const {
   if (params.did_create_new_entry) {
     // A new entry. We may or may not have a pending entry for the page, and
     // this may or may not be the main frame.
-    if (!rfh->GetParent()) {
-      return NAVIGATION_TYPE_NEW_PAGE;
-    }
-
-    // When this is a new subframe navigation, we should have a committed page
-    // in which it's a subframe. This may not be the case when an iframe is
-    // navigated on a popup navigated to about:blank (the iframe would be
-    // written into the popup by script on the main page). For these cases,
-    // there isn't any navigation stuff we can do, so just ignore it.
-    if (!GetLastCommittedEntry())
-      return NAVIGATION_TYPE_NAV_IGNORE;
-
-    // Valid subframe navigation.
-    return NAVIGATION_TYPE_NEW_SUBFRAME;
+    return rfh->GetParent() ?
+        NAVIGATION_TYPE_NEW_SUBFRAME :
+        NAVIGATION_TYPE_NEW_PAGE;
   }
 
   // We only clear the session history when navigating to a new page.
   DCHECK(!params.history_list_was_cleared);
 
   if (rfh->GetParent()) {
     // All manual subframes would be did_create_new_entry and handled above, so
     // we know this is auto.
-    if (GetLastCommittedEntry()) {
-      return NAVIGATION_TYPE_AUTO_SUBFRAME;
-    } else {
-      // We ignore subframes created in non-committed pages; we'd appreciate if
-      // people stopped doing that.
-      return NAVIGATION_TYPE_NAV_IGNORE;
-    }
+    return NAVIGATION_TYPE_AUTO_SUBFRAME;
   }
 
   if (params.nav_entry_id == 0) {
     // This is a renderer-initiated navigation (nav_entry_id == 0), but didn't
-    // create a new page.
-
-    // Just like above in the did_create_new_entry case, it's possible to
-    // scribble onto an uncommitted page. Again, there isn't any navigation
-    // stuff that we can do, so ignore it here as well.
-    NavigationEntry* last_committed = GetLastCommittedEntry();
-    if (!last_committed)
-      return NAVIGATION_TYPE_NAV_IGNORE;
-
-    // This is history.replaceState(), history.reload(), or a client-side
-    // redirect.
+    // create a new page. This happens for history.replaceState(),
+    // history.reload(), or a client-side redirect.
     return NAVIGATION_TYPE_EXISTING_PAGE;
   }
 
   if (pending_entry_ && pending_entry_index_ == -1 &&
       pending_entry_->GetUniqueID() == params.nav_entry_id) {
     // In this case, we have a pending entry for a load of a new URL but Blink
     // didn't do a new navigation (params.did_create_new_entry). First check to
     // make sure Blink didn't treat a new cross-process navigation as inert, and
     // thus set params.did_create_new_entry to false. In that case, we must
     // treat it as NEW since the SiteInstance doesn't match the entry.
@@ skipping 336 matching lines @@
 // and assume the renderer is malicious if a cross-origin navigation claims to
 // be in-page.
 bool NavigationControllerImpl::IsURLInPageNavigation(
     const GURL& url,
     bool renderer_says_in_page,
     RenderFrameHost* rfh) const {
   GURL last_committed_url;
   if (rfh->GetParent()) {
     last_committed_url = rfh->GetLastCommittedURL();
   } else {
-    NavigationEntry* last_committed = GetLastCommittedEntry();
-    // There must be a last-committed entry to compare URLs to. TODO(avi): When
-    // might Blink say that a navigation is in-page yet there be no last-
-    // committed entry?
-    if (!last_committed)
-      return false;
-    last_committed_url = last_committed->GetURL();
+    last_committed_url = GetLastCommittedEntry()->GetURL();
   }
 
   WebPreferences prefs = rfh->GetRenderViewHost()->GetWebkitPreferences();
   bool is_same_origin = last_committed_url.is_empty() ||
                         // TODO(japhet): We should only permit navigations
                         // originating from about:blank to be in-page if the
                         // about:blank is the first document that frame loaded.
                         // We don't have sufficient information to identify
                         // that case at the moment, so always allow about:blank
                         // for now.
                         last_committed_url == GURL(url::kAboutBlankURL) ||
                         last_committed_url.GetOrigin() == url.GetOrigin() ||
                         !prefs.web_security_enabled ||
                         (prefs.allow_universal_access_from_file_urls &&
                          last_committed_url.SchemeIs(url::kFileScheme));
   if (!is_same_origin && renderer_says_in_page) {
     bad_message::ReceivedBadMessage(rfh->GetProcess(),
                                     bad_message::NC_IN_PAGE_NAVIGATION);
   }
   return is_same_origin && renderer_says_in_page;
 }
 
 void NavigationControllerImpl::CopyStateFrom(
     const NavigationController& temp) {
   const NavigationControllerImpl& source =
       static_cast<const NavigationControllerImpl&>(temp);
   // Verify that we look new.
-  DCHECK(GetEntryCount() == 0 && !GetPendingEntry());
-
-  if (source.GetEntryCount() == 0)
-    return;  // Nothing new to do.
+  DCHECK(IsInitialBlankNavigation() && GetEntryCount() == 1 &&
+         !GetPendingEntry());
+  DCHECK_GT(source.GetEntryCount(), 0);
 
   needs_reload_ = true;
+  // Drop the initial entry first.
+  entries_.pop_back();
   InsertEntriesFrom(source, source.GetEntryCount());
 
   for (SessionStorageNamespaceMap::const_iterator it =
            source.session_storage_namespace_map_.begin();
        it != source.session_storage_namespace_map_.end();
        ++it) {
     SessionStorageNamespaceImpl* source_namespace =
         static_cast<SessionStorageNamespaceImpl*>(it->second.get());
     session_storage_namespace_map_[it->first] = source_namespace->Clone();
   }
@@ skipping 56 matching lines @@
   delegate_->CopyMaxPageIDsFrom(source->delegate()->GetWebContents());
   delegate_->UpdateMaxPageIDForSiteInstance(last_committed->site_instance(),
                                             site_max_page_id);
   max_restored_page_id_ = source->max_restored_page_id_;
 }
 
 bool NavigationControllerImpl::CanPruneAllButLastCommitted() {
   // If there is no last committed entry, we cannot prune.  Even if there is a
   // pending entry, it may not commit, leaving this WebContents blank, despite
   // possibly giving it new entries via CopyStateFromAndPrune.
-  if (last_committed_entry_index_ == -1)
+  if (IsInitialBlankNavigation())
     return false;
 
   // We cannot prune if there is a pending entry at an existing entry index.
   // It may not commit, so we have to keep the last committed entry, and thus
   // there is no sensible place to keep the pending entry.  It is ok to have
   // a new pending entry, which can optionally commit as a new navigation.
   if (pending_entry_index_ != -1)
     return false;
 
   // We should not prune if we are currently showing a transient entry.
@@ skipping 47 matching lines @@
 }
 
 void NavigationControllerImpl::SetMaxRestoredPageID(int32 max_id) {
   max_restored_page_id_ = max_id;
 }
 
 int32 NavigationControllerImpl::GetMaxRestoredPageID() const {
   return max_restored_page_id_;
 }
 
+void NavigationControllerImpl::Init(SiteInstance* instance) {
+  DCHECK(IsInitialNavigation());
+
+  // Start with an entry for the initial about:blank page, which will be
+  // replaced on first navigation.
+  scoped_ptr<NavigationEntryImpl> initial_entry =
+      make_scoped_ptr(new NavigationEntryImpl(
+          static_cast<SiteInstanceImpl*>(instance), -1,
+          GURL(url::kAboutBlankURL), Referrer(), base::string16(),
+          ui::PAGE_TRANSITION_LINK, false));
+
+  // Make sure the initial RenderFrameHost knows about it.
+  RenderFrameHostImpl* main_frame =
+      delegate_->GetFrameTree()->root()->current_frame_host();
+  static_cast<RenderViewHostImpl*>(main_frame->GetRenderViewHost())->
+      set_nav_entry_id(initial_entry->GetUniqueID());
+
+  entries_.push_back(initial_entry.Pass());
+}
+
 bool NavigationControllerImpl::IsUnmodifiedBlankTab() const {
-  return IsInitialNavigation() &&
-         !GetLastCommittedEntry() &&
+  return IsInitialBlankNavigation() &&
          !delegate_->HasAccessedInitialDocument();
 }
 
 SessionStorageNamespace*
 NavigationControllerImpl::GetSessionStorageNamespace(SiteInstance* instance) {
   std::string partition_id;
   if (instance) {
     // TODO(ajwong): When GetDefaultSessionStorageNamespace() goes away, remove
     // this if statement so |instance| must not be NULL.
     partition_id =
@@ skipping 427 matching lines @@
 NavigationEntryImpl* NavigationControllerImpl::GetTransientEntry() const {
   if (transient_entry_index_ == -1)
     return NULL;
   return entries_[transient_entry_index_];
 }
 
 void NavigationControllerImpl::SetTransientEntry(
     scoped_ptr<NavigationEntry> entry) {
   // Discard any current transient entry, we can only have one at a time.
   int index = 0;
-  if (last_committed_entry_index_ != -1)
-    index = last_committed_entry_index_ + 1;
+  index = last_committed_entry_index_ + 1;
   DiscardTransientEntry();
   entries_.insert(entries_.begin() + index,
                   NavigationEntryImpl::FromNavigationEntry(entry.release()));
   transient_entry_index_ = index;
   delegate_->NotifyNavigationStateChanged(INVALIDATE_TYPE_ALL);
 }
 
 void NavigationControllerImpl::InsertEntriesFrom(
     const NavigationControllerImpl& source,
     int max_index) {
@@ skipping 10 matching lines @@
     }
   }
 }
 
 void NavigationControllerImpl::SetGetTimestampCallbackForTest(
     const base::Callback<base::Time()>& get_timestamp_callback) {
   get_timestamp_callback_ = get_timestamp_callback;
 }
 
 }  // namespace content