Moves fields only accessed from content::DocumentState to content::InternalDocumentStateData.

content/renderer/render_view_impl.cc

 // Copyright (c) 2012 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_view_impl.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/auto_reset.h"
@@ skipping 381 matching lines @@
   ds->redirectChain(urls);
   result->reserve(urls.size());
   for (size_t i = 0; i < urls.size(); ++i) {
     if (urls[i] != GURL(kSwappedOutURL))
       result->push_back(urls[i]);
     else
       result->push_back(blank_url);
   }
 }
 
-// If |data_source| is non-null and has a DocumentState associated with it,
-// the AltErrorPageResourceFetcher is reset.
+// If |data_source| is non-null and has an InternalDocumentStateData associated
+// with it, the AltErrorPageResourceFetcher is reset.
 static void StopAltErrorPageFetcher(WebDataSource* data_source) {
   if (data_source) {
-    DocumentState* document_state = DocumentState::FromDataSource(data_source);
-    if (document_state)
-      document_state->set_alt_error_page_fetcher(NULL);
+    InternalDocumentStateData* internal_data =
+        InternalDocumentStateData::FromDataSource(data_source);
+    if (internal_data)
+      internal_data->set_alt_error_page_fetcher(NULL);
   }
 }
 
 static bool IsReload(const ViewMsg_Navigate_Params& params) {
   return
       params.navigation_type == ViewMsg_Navigate_Type::RELOAD ||
       params.navigation_type == ViewMsg_Navigate_Type::RELOAD_IGNORING_CACHE ||
       params.navigation_type ==
           ViewMsg_Navigate_Type::RELOAD_ORIGINAL_REQUEST_URL;
 }
@@ skipping 1185 matching lines @@
 void RenderViewImpl::UpdateURL(WebFrame* frame) {
   WebDataSource* ds = frame->dataSource();
   DCHECK(ds);
 
   const WebURLRequest& request = ds->request();
   const WebURLRequest& original_request = ds->originalRequest();
   const WebURLResponse& response = ds->response();
 
   DocumentState* document_state = DocumentState::FromDataSource(ds);
   NavigationState* navigation_state = document_state->navigation_state();
+  InternalDocumentStateData* internal_data =
+      InternalDocumentStateData::FromDocumentState(document_state);
 
   ViewHostMsg_FrameNavigate_Params params;
   params.http_status_code = response.httpStatusCode();
   params.is_post = false;
   params.post_id = -1;
   params.page_id = page_id_;
   params.frame_id = frame->identifier();
   params.socket_address.set_host(response.remoteIPAddress().utf8());
   params.socket_address.set_port(response.remotePort());
   WebURLResponseExtraDataImpl* extra_data = GetExtraDataFromResponse(response);
   if (extra_data) {
     params.was_fetched_via_proxy = extra_data->was_fetched_via_proxy();
   }
   params.was_within_same_page = navigation_state->was_within_same_page();
-  if (!document_state->security_info().empty()) {

[sky, 2013/04/08 16:53:49]

I removed scurity_info entirely as it didn't appear anyone was setting it, so
that it was always empty.

-    // SSL state specified in the request takes precedence over the one in the
-    // response.
-    // So far this is only intended for error pages that are not expected to be
-    // over ssl, so we should not get any clash.
-    DCHECK(response.securityInfo().isEmpty());
-    params.security_info = document_state->security_info();
-  } else {
-    params.security_info = response.securityInfo();
-  }
+  params.security_info = response.securityInfo();
 
   // Set the URL to be displayed in the browser UI to the user.
   params.url = GetLoadingUrl(frame);
   DCHECK(!is_swapped_out_ || params.url == GURL(kSwappedOutURL));
 
   if (frame->document().baseURL() != params.url)
     params.base_url = frame->document().baseURL();
 
   GetRedirectChain(ds, &params.redirects);
   params.should_update_history = !ds->hasUnreachableURL() &&
       !response.isMultipartPayload() && (response.httpStatusCode() != 404);
 
-  params.searchable_form_url = document_state->searchable_form_url();
-  params.searchable_form_encoding =
-      document_state->searchable_form_encoding();
+  params.searchable_form_url = internal_data->searchable_form_url();
+  params.searchable_form_encoding = internal_data->searchable_form_encoding();
 
-  const PasswordForm* password_form_data =
-      document_state->password_form_data();
+  const PasswordForm* password_form_data = document_state->password_form_data();
   if (password_form_data)
     params.password_form = *password_form_data;
 
   params.gesture = navigation_gesture_;
   navigation_gesture_ = NavigationGestureUnknown;
 
   // Make navigation state a part of the FrameNavigate message so that commited
   // entry had it at all times.
   const WebHistoryItem& item = frame->currentHistoryItem();
   if (!item.isNull()) {
@@ skipping 67 matching lines @@
           GetReferrerPolicyFromRequest(frame, original_request));
     }
 
     string16 method = request.httpMethod();
     if (EqualsASCII(method, "POST")) {
       params.is_post = true;
       params.post_id = ExtractPostId(item);
     }
 
     // Send the user agent override back.
-    params.is_overriding_user_agent =
-        document_state->is_overriding_user_agent();
+    params.is_overriding_user_agent = internal_data->is_overriding_user_agent();
 
     // Track the URL of the original request.
     params.original_request_url = original_request.url();
 
     // Save some histogram data so we can compute the average memory used per
     // page load of the glyphs.
     UMA_HISTOGRAM_COUNTS_10000("Memory.GlyphPagesPerLoad",
                                webkit_glue::GetGlyphPageCount());
 
     // This message needs to be sent before any of allowScripts(),
@@ skipping 1079 matching lines @@
   EditCommands edit_commands;
   edit_commands.push_back(EditCommand(name, value));
   OnSetEditCommandsForNextKeyEvent(edit_commands);
 }
 
 void RenderViewImpl::ClearEditCommands() {
   edit_commands_.clear();
 }
 
 SSLStatus RenderViewImpl::GetSSLStatusOfFrame(WebKit::WebFrame* frame) const {
-  SSLStatus ssl_status;
-
-  DocumentState* doc_state = DocumentState::FromDataSource(frame->dataSource());
-  if (doc_state && !doc_state->security_info().empty()) {
-    DeserializeSecurityInfo(doc_state->security_info(),
-                            &ssl_status.cert_id,
-                            &ssl_status.cert_status,
-                            &ssl_status.security_bits,
-                            &ssl_status.connection_status);
-  }
-
-  return ssl_status;
+  return SSLStatus();

[Dan Beam, 2013/07/03 17:44:36]

what is the point of this method now?

 }
 
 void RenderViewImpl::loadURLExternally(
     WebFrame* frame, const WebURLRequest& request,
     WebNavigationPolicy policy,
     const WebString& suggested_name) {
   Referrer referrer(
       GURL(request.httpHeaderField(WebString::fromUTF8("Referer"))),
       GetReferrerPolicyFromRequest(frame, request));
   if (policy == WebKit::WebNavigationPolicyDownload) {
@@ skipping 237 matching lines @@
   DocumentState* document_state =
       DocumentState::FromDataSource(frame->dataSource());
   document_state->set_password_form_data(CreatePasswordForm(form));
 }
 
 void RenderViewImpl::willSubmitForm(WebFrame* frame,
                                     const WebFormElement& form) {
   DocumentState* document_state =
       DocumentState::FromDataSource(frame->provisionalDataSource());
   NavigationState* navigation_state = document_state->navigation_state();
+  InternalDocumentStateData* internal_data =
+      InternalDocumentStateData::FromDocumentState(document_state);
 
   if (navigation_state->transition_type() == PAGE_TRANSITION_LINK)
     navigation_state->set_transition_type(PAGE_TRANSITION_FORM_SUBMIT);
 
   // Save these to be processed when the ensuing navigation is committed.
   WebSearchableFormData web_searchable_form_data(form);
-  document_state->set_searchable_form_url(web_searchable_form_data.url());
-  document_state->set_searchable_form_encoding(
+  internal_data->set_searchable_form_url(web_searchable_form_data.url());
+  internal_data->set_searchable_form_encoding(
       web_searchable_form_data.encoding().utf8());
   scoped_ptr<PasswordForm> password_form_data =
       CreatePasswordForm(form);
 
   // In order to save the password that the user actually typed and not one
   // that may have gotten transformed by the site prior to submit, recover it
   // from the form contents already stored by |willSendSubmitEvent| into the
   // dataSource's NavigationState (as opposed to the provisionalDataSource's,
   // which is what we're storing into now.)
   if (password_form_data.get()) {
@@ skipping 58 matching lines @@
     if (!content_initiated)
       PopulateDocumentStateFromPending(document_state);
   }
 
   // Carry over the user agent override flag, if it exists.
   if (content_initiated && webview() && webview()->mainFrame() &&
       webview()->mainFrame()->dataSource()) {
     DocumentState* old_document_state =
         DocumentState::FromDataSource(webview()->mainFrame()->dataSource());
     if (old_document_state) {
-      document_state->set_is_overriding_user_agent(
-          old_document_state->is_overriding_user_agent());
+      InternalDocumentStateData* internal_data =
+          InternalDocumentStateData::FromDocumentState(document_state);
+      InternalDocumentStateData* old_internal_data =
+          InternalDocumentStateData::FromDocumentState(old_document_state);
+      internal_data->set_is_overriding_user_agent(
+          old_internal_data->is_overriding_user_agent());
     }
   }
 
   // The rest of RenderView assumes that a WebDataSource will always have a
   // non-null NavigationState.
   if (content_initiated) {
     document_state->set_navigation_state(
         NavigationState::CreateContentInitiated());
   } else {
     document_state->set_navigation_state(CreateNavigationStateFromPending());
@@ skipping 47 matching lines @@
 
   FOR_EACH_OBSERVER(
       RenderViewObserver, observers_, DidCreateDataSource(frame, ds));
 }
 
 void RenderViewImpl::PopulateDocumentStateFromPending(
     DocumentState* document_state) {
   const ViewMsg_Navigate_Params& params = *pending_navigation_params_.get();
   document_state->set_request_time(params.request_time);
 
+  InternalDocumentStateData* internal_data =
+      InternalDocumentStateData::FromDocumentState(document_state);
+
   if (!params.url.SchemeIs(chrome::kJavaScriptScheme) &&
       params.navigation_type == ViewMsg_Navigate_Type::RESTORE) {
     // We're doing a load of a page that was restored from the last session. By
     // default this prefers the cache over loading (LOAD_PREFERRING_CACHE) which
     // can result in stale data for pages that are set to expire. We explicitly
     // override that by setting the policy here so that as necessary we load
     // from the network.
-    document_state->set_cache_policy_override(
+    internal_data->set_cache_policy_override(
         WebURLRequest::UseProtocolCachePolicy);
   }
 
   if (IsReload(params))
     document_state->set_load_type(DocumentState::RELOAD);
   else if (!params.state.empty())
     document_state->set_load_type(DocumentState::HISTORY_LOAD);
   else
     document_state->set_load_type(DocumentState::NORMAL_LOAD);
 
-  document_state->set_referrer_policy(params.referrer.policy);
-  document_state->set_is_overriding_user_agent(params.is_overriding_user_agent);
-  document_state->set_must_reset_scroll_and_scale_state(
+  internal_data->set_referrer_policy(params.referrer.policy);
+  internal_data->set_is_overriding_user_agent(params.is_overriding_user_agent);
+  internal_data->set_must_reset_scroll_and_scale_state(
       params.navigation_type ==
           ViewMsg_Navigate_Type::RELOAD_ORIGINAL_REQUEST_URL);
   document_state->set_can_load_local_resources(params.can_load_local_resources);
 }
 
 NavigationState* RenderViewImpl::CreateNavigationStateFromPending() {
   const ViewMsg_Navigate_Params& params = *pending_navigation_params_.get();
   NavigationState* navigation_state = NULL;
 
   // A navigation resulting from loading a javascript URL should not be treated
@@ skipping 211 matching lines @@
   if (MaybeLoadAlternateErrorPage(frame, error, replace))
     return;
 
   // Fallback to a local error page.
   LoadNavigationErrorPage(frame, failed_request, error, std::string(), replace);
 }
 
 void RenderViewImpl::didReceiveDocumentData(
     WebFrame* frame, const char* data, size_t data_len,
     bool& prevent_default) {
-  DocumentState* document_state =
-      DocumentState::FromDataSource(frame->dataSource());
-  document_state->set_use_error_page(false);
+  InternalDocumentStateData* internal_data =
+      InternalDocumentStateData::FromDataSource(frame->dataSource());
+  internal_data->set_use_error_page(false);
 }
 
 void RenderViewImpl::didCommitProvisionalLoad(WebFrame* frame,
                                               bool is_new_navigation) {
   DocumentState* document_state =
       DocumentState::FromDataSource(frame->dataSource());
   NavigationState* navigation_state = document_state->navigation_state();
+  InternalDocumentStateData* internal_data =
+      InternalDocumentStateData::FromDocumentState(document_state);
 
   if (document_state->commit_load_time().is_null())
     document_state->set_commit_load_time(Time::Now());
 
-  if (document_state->must_reset_scroll_and_scale_state()) {
+  if (internal_data->must_reset_scroll_and_scale_state()) {
     webview()->resetScrollAndScaleState();
-    document_state->set_must_reset_scroll_and_scale_state(false);
+    internal_data->set_must_reset_scroll_and_scale_state(false);
   }
 
   if (is_new_navigation) {
     // When we perform a new navigation, we need to update the last committed
     // session history entry with state for the page we are leaving.
     UpdateSessionHistory(frame);
 
     // We bump our Page ID to correspond with the new session history entry.
     page_id_ = next_page_id_++;
 
@@ skipping 224 matching lines @@
   if (!top_frame)
     top_frame = frame;
   WebDataSource* provisional_data_source = top_frame->provisionalDataSource();
   WebDataSource* top_data_source = top_frame->dataSource();
   WebDataSource* data_source =
       provisional_data_source ? provisional_data_source : top_data_source;
 
   PageTransition transition_type = PAGE_TRANSITION_LINK;
   DocumentState* document_state = DocumentState::FromDataSource(data_source);
   DCHECK(document_state);
+  InternalDocumentStateData* internal_data =
+      InternalDocumentStateData::FromDocumentState(document_state);
   NavigationState* navigation_state = document_state->navigation_state();
   transition_type = navigation_state->transition_type();
 
   GURL request_url(request.url());
   GURL new_url;
   if (GetContentClient()->renderer()->WillSendRequest(
           frame,
           transition_type,
           request_url,
           request.firstPartyForCookies(),
           &new_url)) {
     request.setURL(WebURL(new_url));
   }
 
-  if (document_state->is_cache_policy_override_set())
-    request.setCachePolicy(document_state->cache_policy_override());
+  if (internal_data->is_cache_policy_override_set())
+    request.setCachePolicy(internal_data->cache_policy_override());
 
   WebKit::WebReferrerPolicy referrer_policy;
-  if (document_state && document_state->is_referrer_policy_set()) {
-    referrer_policy = document_state->referrer_policy();
-    document_state->clear_referrer_policy();
+  if (internal_data->is_referrer_policy_set()) {
+    referrer_policy = internal_data->referrer_policy();
+    internal_data->clear_referrer_policy();
   } else {
     referrer_policy = frame->document().referrerPolicy();
   }
 
   // The request's extra data may indicate that we should set a custom user
   // agent. This needs to be done here, after WebKit is through with setting the
   // user agent on its own.
   WebString custom_user_agent;
   if (request.extraData()) {
     webkit_glue::WebURLRequestExtraDataImpl* old_extra_data =
@@ skipping 72 matching lines @@
         extra_data->was_fetched_via_spdy());
     document_state->set_was_npn_negotiated(
         extra_data->was_npn_negotiated());
     document_state->set_npn_negotiated_protocol(
         extra_data->npn_negotiated_protocol());
     document_state->set_was_alternate_protocol_available(
         extra_data->was_alternate_protocol_available());
     document_state->set_was_fetched_via_proxy(
         extra_data->was_fetched_via_proxy());
   }
-  document_state->set_http_status_code(http_status_code);
+  InternalDocumentStateData* internal_data =
+      InternalDocumentStateData::FromDocumentState(document_state);
+  internal_data->set_http_status_code(http_status_code);
   // Whether or not the http status code actually corresponds to an error is
   // only checked when the page is done loading, if |use_error_page| is
   // still true.
-  document_state->set_use_error_page(true);
+  internal_data->set_use_error_page(true);
 }
 
 void RenderViewImpl::didFinishResourceLoad(
     WebFrame* frame, unsigned identifier) {
-  DocumentState* document_state =
-      DocumentState::FromDataSource(frame->dataSource());
-  if (!document_state->use_error_page())
+  InternalDocumentStateData* internal_data =
+      InternalDocumentStateData::FromDataSource(frame->dataSource());
+  if (!internal_data->use_error_page())
     return;
 
   // Do not show error page when DevTools is attached.
   if (devtools_agent_->IsAttached())
     return;
 
   // Display error page, if appropriate.
-  int http_status_code = document_state->http_status_code();
+  int http_status_code = internal_data->http_status_code();
   if (http_status_code == 404) {
     // On 404s, try a remote search page as a fallback.
     const GURL& document_url = frame->document().url();
 
     const GURL& error_page_url =
         GetAlternateErrorPageURL(document_url, HTTP_404);
     if (error_page_url.is_valid()) {
       WebURLError original_error;
       original_error.domain = "http";
       original_error.reason = 404;
       original_error.unreachableURL = document_url;
 
-      document_state->set_alt_error_page_fetcher(
+      internal_data->set_alt_error_page_fetcher(
           new AltErrorPageResourceFetcher(
               error_page_url, frame, original_error,
               base::Bind(&RenderViewImpl::AltErrorPageFinished,
                          base::Unretained(this))));
       return;
     }
   }
 
   std::string error_domain;
   if (GetContentClient()->renderer()->HasErrorPage(
@@ skipping 456 matching lines @@
 
   // If we're in the middle of committing a load, the data source we need
   // will still be provisional.
   WebFrame* main_frame = webview()->mainFrame();
   WebDataSource* data_source = NULL;
   if (main_frame->provisionalDataSource())
     data_source = main_frame->provisionalDataSource();
   else
     data_source = main_frame->dataSource();
 
-  DocumentState* document_state =
-      data_source ? DocumentState::FromDataSource(data_source) : NULL;
-  if (document_state && document_state->is_overriding_user_agent())
+  InternalDocumentStateData* internal_data = data_source ?
+      InternalDocumentStateData::FromDataSource(data_source) : NULL;
+  if (internal_data && internal_data->is_overriding_user_agent())
     return WebString::fromUTF8(renderer_preferences_.user_agent_override);
-  else
-    return WebKit::WebString();
+  return WebKit::WebString();
 }
 
 bool RenderViewImpl::allowWebGL(WebFrame* frame, bool default_value) {
   if (!default_value)
     return false;
 
   bool blocked = true;
   Send(new ViewHostMsg_Are3DAPIsBlocked(
       routing_id_,
       GURL(frame->top()->document().securityOrigin().toString()),
@@ skipping 1185 matching lines @@
   // Load an empty page first so there is an immediate response to the error,
   // and then kick off a request for the alternate error page.
   frame->loadHTMLString(std::string(),
                         GURL(kUnreachableWebDataURL),
                         error.unreachableURL,
                         replace);
 
   // Now, create a fetcher for the error page and associate it with the data
   // source we just created via the LoadHTMLString call.  That way if another
   // navigation occurs, the fetcher will get destroyed.
-  DocumentState* document_state =
-      DocumentState::FromDataSource(frame->provisionalDataSource());
-  document_state->set_alt_error_page_fetcher(
+  InternalDocumentStateData* internal_data =
+      InternalDocumentStateData::FromDataSource(frame->provisionalDataSource());
+  internal_data->set_alt_error_page_fetcher(
       new AltErrorPageResourceFetcher(
           error_page_url, frame, error,
           base::Bind(&RenderViewImpl::AltErrorPageFinished,
                      base::Unretained(this))));
   return true;
 }
 
 void RenderViewImpl::AltErrorPageFinished(WebFrame* frame,
                                           const WebURLError& original_error,
                                           const std::string& html) {
@@ skipping 48 matching lines @@
   if (!webview())
     return;
 
   WebFrame* main_frame = webview()->mainFrame();
 
   // If we have a provisional frame we are between the start and commit stages
   // of loading and we don't want to save stats.
   if (!main_frame->provisionalDataSource()) {
     WebDataSource* ds = main_frame->dataSource();
     DocumentState* document_state = DocumentState::FromDataSource(ds);
-
     InternalDocumentStateData* data =
-        InternalDocumentStateData::FromDataSource(ds);
+        InternalDocumentStateData::FromDocumentState(document_state);
     if (data->did_first_visually_non_empty_layout() &&
         !data->did_first_visually_non_empty_paint()) {
       data->set_did_first_visually_non_empty_paint(true);
       Send(new ViewHostMsg_DidFirstVisuallyNonEmptyPaint(routing_id_,
                                                          page_id_));
     }
 
     // TODO(jar): The following code should all be inside a method, probably in
     // NavigatorState.
     Time now = Time::Now();
@@ skipping 921 matching lines @@
     WebURL url = icon_urls[i].iconURL();
     if (!url.isEmpty())
       urls.push_back(FaviconURL(url,
                                 ToFaviconType(icon_urls[i].iconType())));
   }
   SendUpdateFaviconURL(urls);
 }
 
 
 }  // namespace content