Revert "Keep a copy of page id in RenderViewHost."

content/renderer/render_frame_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.
 
 #include "content/renderer/render_frame_impl.h"
 
 #include <map>
 #include <string>
 
 #include "base/auto_reset.h"
@@ skipping 1988 matching lines @@
   // Received a redirect on the main frame.
   WebDataSource* data_source = frame->provisionalDataSource();
   if (!data_source) {
     // Should only be invoked when we have a data source.
     NOTREACHED();
     return;
   }
   std::vector<GURL> redirects;
   GetRedirectChain(data_source, &redirects);
   if (redirects.size() >= 2) {
-    CHECK(!render_view_->page_id_not_yet_reported_);
     Send(new FrameHostMsg_DidRedirectProvisionalLoad(
         routing_id_,
         render_view_->page_id_,
         redirects[redirects.size() - 2],
         redirects.back()));
   }
 }
 
 void RenderFrameImpl::didFailProvisionalLoad(blink::WebLocalFrame* frame,
                                              const blink::WebURLError& error) {
@@ skipping 129 matching lines @@
   if (internal_data->must_reset_scroll_and_scale_state()) {
     render_view_->webview()->resetScrollAndScaleState();
     internal_data->set_must_reset_scroll_and_scale_state(false);
   }
   internal_data->set_use_error_page(false);
 
   bool is_new_navigation = commit_type == blink::WebStandardCommit;
   if (is_new_navigation) {
     // We bump our Page ID to correspond with the new session history entry.
     render_view_->page_id_ = render_view_->next_page_id_++;
-    render_view_->page_id_not_yet_reported_ = true;
 
     // Don't update history_page_ids_ (etc) for kSwappedOutURL, since
     // we don't want to forget the entry that was there, and since we will
     // never come back to kSwappedOutURL.  Note that we have to call
     // UpdateSessionHistory and update page_id_ even in this case, so that
     // the current entry gets a state update and so that we don't send a
     // state update to the wrong entry when we swap back in.
     if (GetLoadingUrl() != GURL(kSwappedOutURL)) {
       // Advance our offset in session history, applying the length limit.
       // There is now no forward history.
@@ skipping 16 matching lines @@
     // per navigation.
     //
     // Note that we need to check if the page ID changed. In the case of a
     // reload, the page ID doesn't change, and UpdateSessionHistory gets the
     // previous URL and the current page ID, which would be wrong.
     if (navigation_state->pending_page_id() != -1 &&
         navigation_state->pending_page_id() != render_view_->page_id_ &&
         !navigation_state->request_committed()) {
       // This is a successful session history navigation!
       render_view_->page_id_ = navigation_state->pending_page_id();
-      render_view_->page_id_not_yet_reported_ = true;
 
       render_view_->history_list_offset_ =
           navigation_state->pending_history_list_offset();
 
       // If the history list is valid, our list of page IDs should be correct.
       DCHECK(render_view_->history_list_length_ <= 0 ||
              render_view_->history_list_offset_ < 0 ||
              render_view_->history_list_offset_ >=
                  render_view_->history_list_length_ ||
              render_view_->history_page_ids_[render_view_->history_list_offset_]
@@ skipping 70 matching lines @@
                                       const blink::WebString& title,
                                       blink::WebTextDirection direction) {
   DCHECK(!frame_ || frame_ == frame);
   // Ignore all but top level navigations.
   if (!frame->parent()) {
     base::string16 title16 = title;
     base::debug::TraceLog::GetInstance()->UpdateProcessLabel(
         routing_id_, base::UTF16ToUTF8(title16));
 
     base::string16 shortened_title = title16.substr(0, kMaxTitleChars);
-    CHECK(!render_view_->page_id_not_yet_reported_);
     Send(new FrameHostMsg_UpdateTitle(routing_id_,
                                       render_view_->page_id_,
                                       shortened_title, direction));
   }
 
   // Also check whether we have new encoding name.
   UpdateEncoding(frame, frame->view()->pageEncoding().utf8());
 }
 
 void RenderFrameImpl::didChangeIcon(blink::WebLocalFrame* frame,
@@ skipping 1066 matching lines @@
     else
       params.transition = PAGE_TRANSITION_AUTO_SUBFRAME;
 
     DCHECK(!navigation_state->history_list_was_cleared());
     params.history_list_was_cleared = false;
 
     // Don't send this message while the subframe is swapped out.
     if (!is_swapped_out())
       Send(new FrameHostMsg_DidCommitProvisionalLoad(routing_id_, params));
   }
-  render_view_->page_id_not_yet_reported_ = false;
 
   render_view_->last_page_id_sent_to_browser_ =
       std::max(render_view_->last_page_id_sent_to_browser_,
                render_view_->page_id_);
 
   // If we end up reusing this WebRequest (for example, due to a #ref click),
   // we don't want the transition type to persist.  Just clear it.
   navigation_state->set_transition_type(PAGE_TRANSITION_LINK);
 }
 
@@ skipping 469 matching lines @@
 
 #if defined(ENABLE_BROWSER_CDMS)
 RendererCdmManager* RenderFrameImpl::GetCdmManager() {
   if (!cdm_manager_)
     cdm_manager_ = new RendererCdmManager(this);
   return cdm_manager_;
 }
 #endif  // defined(ENABLE_BROWSER_CDMS)
 
 }  // namespace content