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

content/public/renderer/document_state.h

 // 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.
 
 #ifndef CONTENT_PUBLIC_RENDERER_DOCUMENT_STATE_H_
 #define CONTENT_PUBLIC_RENDERER_DOCUMENT_STATE_H_
 
 #include <string>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/supports_user_data.h"
 #include "base/time.h"
-#include "third_party/WebKit/Source/Platform/chromium/public/WebReferrerPolicy.h"
-#include "third_party/WebKit/Source/Platform/chromium/public/WebURLRequest.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDataSource.h"
 
-namespace webkit_glue {
-class AltErrorPageResourceFetcher;
-}
-
 namespace content {
 
 class NavigationState;
 struct PasswordForm;
 
 // The RenderView stores an instance of this class in the "extra data" of each
 // WebDataSource (see RenderView::DidCreateDataSource).
 class DocumentState : public WebKit::WebDataSource::ExtraData,
                       public base::SupportsUserData {
  public:
@@ skipping 92 matching lines @@
     load_histograms_recorded_ = value;
   }
 
   bool web_timing_histograms_recorded() const {
     return web_timing_histograms_recorded_;
   }
   void set_web_timing_histograms_recorded(bool value) {
     web_timing_histograms_recorded_ = value;
   }
 
-  int http_status_code() const { return http_status_code_; }
-  void set_http_status_code(int http_status_code) {
-    http_status_code_ = http_status_code;
-  }
-
   // Indicator if SPDY was used as part of this page load.
   bool was_fetched_via_spdy() const { return was_fetched_via_spdy_; }
   void set_was_fetched_via_spdy(bool value) { was_fetched_via_spdy_ = value; }
 
   bool was_npn_negotiated() const { return was_npn_negotiated_; }
   void set_was_npn_negotiated(bool value) { was_npn_negotiated_ = value; }
 
   const std::string& npn_negotiated_protocol() const {
     return npn_negotiated_protocol_;
   }
   void set_npn_negotiated_protocol(const std::string& value) {
     npn_negotiated_protocol_ = value;
   }
 
   bool was_alternate_protocol_available() const {
     return was_alternate_protocol_available_;
   }
   void set_was_alternate_protocol_available(bool value) {
     was_alternate_protocol_available_ = value;
   }
 
   bool was_fetched_via_proxy() const { return was_fetched_via_proxy_; }
   void set_was_fetched_via_proxy(bool value) {
     was_fetched_via_proxy_ = value;
   }
 
-  const GURL& searchable_form_url() const { return searchable_form_url_; }
-  void set_searchable_form_url(const GURL& url) { searchable_form_url_ = url; }
-  const std::string& searchable_form_encoding() const {
-    return searchable_form_encoding_;
-  }
-  void set_searchable_form_encoding(const std::string& encoding) {
-    searchable_form_encoding_ = encoding;
-  }
-
   // If set, contains the PasswordForm that we believe triggered the current
   // navigation (there is some ambiguity in the case of javascript initiated
   // navigations). This information is used by the PasswordManager to determine
   // if the user should be prompted to save their password.
   //
   // Note that setting this field doesn't affect where the data is sent or what
   // origin we associate it with, only whether we prompt the user to save it.
   // That is, a false positive is a usability issue (e.g. may try to save a
   // mis-typed password) not a security issue.
   PasswordForm* password_form_data() const {
     return password_form_data_.get();
   }
   void set_password_form_data(scoped_ptr<PasswordForm> data);
 
-  const std::string& security_info() const { return security_info_; }
-  void set_security_info(const std::string& security_info) {
-    security_info_ = security_info;
-  }
-
-  // True if an error page should be used, if the http status code also
-  // indicates an error.
-  bool use_error_page() const { return use_error_page_; }
-  void set_use_error_page(bool use_error_page) {
-    use_error_page_ = use_error_page;
-  }
-
-  // True if the user agent was overridden for this page.
-  bool is_overriding_user_agent() const { return is_overriding_user_agent_; }
-  void set_is_overriding_user_agent(bool state) {
-    is_overriding_user_agent_ = state;
-  }
-
-  // True if we have to reset the scroll and scale state of the page
-  // after the provisional load has been committed.
-  bool must_reset_scroll_and_scale_state() const {
-    return must_reset_scroll_and_scale_state_;
-  }
-  void set_must_reset_scroll_and_scale_state(bool state) {
-    must_reset_scroll_and_scale_state_ = state;
-  }
-
   void set_was_prefetcher(bool value) { was_prefetcher_ = value; }
   bool was_prefetcher() const { return was_prefetcher_; }
 
   void set_was_referred_by_prefetcher(bool value) {
     was_referred_by_prefetcher_ = value;
   }
   bool was_referred_by_prefetcher() const {
     return was_referred_by_prefetcher_;
   }
 
   // Record the nature of this load, for use when histogramming page load times.
   LoadType load_type() const { return load_type_; }
   void set_load_type(LoadType load_type) { load_type_ = load_type; }
 
-  // Sets the cache policy. The cache policy is only used if explicitly set and
-  // by default is not set. You can mark a NavigationState as not having a cache
-  // state by way of clear_cache_policy_override.
-  void set_cache_policy_override(
-      WebKit::WebURLRequest::CachePolicy cache_policy) {
-    cache_policy_override_ = cache_policy;
-    cache_policy_override_set_ = true;
-  }
-  WebKit::WebURLRequest::CachePolicy cache_policy_override() const {
-    return cache_policy_override_;
-  }
-  void clear_cache_policy_override() {
-    cache_policy_override_set_ = false;
-    cache_policy_override_ = WebKit::WebURLRequest::UseProtocolCachePolicy;
-  }
-  bool is_cache_policy_override_set() const {
-    return cache_policy_override_set_;
-  }
-
-  // Sets the referrer policy to use. This is only used for browser initiated
-  // navigations, otherwise, the referrer policy is defined by the frame's
-  // document.
-  WebKit::WebReferrerPolicy referrer_policy() const {
-    return referrer_policy_;
-  }
-  void set_referrer_policy(WebKit::WebReferrerPolicy referrer_policy) {
-    referrer_policy_ = referrer_policy;
-    referrer_policy_set_ = true;
-  }
-  void clear_referrer_policy() {
-    referrer_policy_ = WebKit::WebReferrerPolicyDefault;
-    referrer_policy_set_ = false;
-  }
-  bool is_referrer_policy_set() const { return referrer_policy_set_; }
-
-  webkit_glue::AltErrorPageResourceFetcher* alt_error_page_fetcher() const {
-    return alt_error_page_fetcher_.get();
-  }
-  void set_alt_error_page_fetcher(webkit_glue::AltErrorPageResourceFetcher* f);
-
   NavigationState* navigation_state() { return navigation_state_.get(); }
   void set_navigation_state(NavigationState* navigation_state);
 
   bool can_load_local_resources() const { return can_load_local_resources_; }
   void set_can_load_local_resources(bool can_load) {
     can_load_local_resources_ = can_load;
   }
 
  private:
   base::Time request_time_;
   base::Time start_load_time_;
   base::Time commit_load_time_;
   base::Time finish_document_load_time_;
   base::Time finish_load_time_;
   base::Time first_paint_time_;
   base::Time first_paint_after_load_time_;
   bool load_histograms_recorded_;
   bool web_timing_histograms_recorded_;
-  int http_status_code_;
   bool was_fetched_via_spdy_;
   bool was_npn_negotiated_;
   std::string npn_negotiated_protocol_;
   bool was_alternate_protocol_available_;
   bool was_fetched_via_proxy_;
 
-  GURL searchable_form_url_;
-  std::string searchable_form_encoding_;
   scoped_ptr<PasswordForm> password_form_data_;
-  std::string security_info_;
-
-  bool use_error_page_;
-
-  bool is_overriding_user_agent_;
-  bool must_reset_scroll_and_scale_state_;
 
   // A prefetcher is a page that contains link rel=prefetch elements.
   bool was_prefetcher_;
   bool was_referred_by_prefetcher_;
 
   LoadType load_type_;
 
-  bool cache_policy_override_set_;
-  WebKit::WebURLRequest::CachePolicy cache_policy_override_;
-
-  bool referrer_policy_set_;
-  WebKit::WebReferrerPolicy referrer_policy_;
-
-  scoped_ptr<webkit_glue::AltErrorPageResourceFetcher> alt_error_page_fetcher_;
-
   scoped_ptr<NavigationState> navigation_state_;
 
   bool can_load_local_resources_;
 };
 
 #endif  // CONTENT_PUBLIC_RENDERER_DOCUMENT_STATE_H_
 
 }  // namespace content