Navigation: move RestoreType and ReloadType into a separate file

content/browser/frame_host/navigator_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/browser/frame_host/navigator_impl.h"
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
@@ skipping 34 matching lines @@
 #include "content/public/common/url_constants.h"
 #include "net/base/net_errors.h"
 #include "url/gurl.h"
 #include "url/url_constants.h"
 
 namespace content {
 
 namespace {
 
 FrameMsg_Navigate_Type::Value GetNavigationType(
-    BrowserContext* browser_context, const NavigationEntryImpl& entry,
-    NavigationController::ReloadType reload_type) {
+    BrowserContext* browser_context,
+    const NavigationEntryImpl& entry,
+    ReloadType reload_type) {
   switch (reload_type) {
-    case NavigationController::RELOAD:
+    case ReloadType::NORMAL:
       return FrameMsg_Navigate_Type::RELOAD;
-    case NavigationController::RELOAD_MAIN_RESOURCE:
+    case ReloadType::MAIN_RESOURCE:
       return FrameMsg_Navigate_Type::RELOAD_MAIN_RESOURCE;
-    case NavigationController::RELOAD_BYPASSING_CACHE:
-    case NavigationController::RELOAD_DISABLE_LOFI_MODE:
+    case ReloadType::BYPASSING_CACHE:
+    case ReloadType::DISABLE_LOFI_MODE:
       return FrameMsg_Navigate_Type::RELOAD_BYPASSING_CACHE;
-    case NavigationController::RELOAD_ORIGINAL_REQUEST_URL:
+    case ReloadType::ORIGINAL_REQUEST_URL:
       return FrameMsg_Navigate_Type::RELOAD_ORIGINAL_REQUEST_URL;
-    case NavigationController::NO_RELOAD:
+    case ReloadType::NONE:
       break;  // Fall through to rest of function.
   }
 
   // |RenderViewImpl::PopulateStateFromPendingNavigationParams| differentiates
   // between |RESTORE_WITH_POST| and |RESTORE|.
-  if (entry.restore_type() ==
-      NavigationEntryImpl::RESTORE_LAST_SESSION_EXITED_CLEANLY) {
+  if (entry.restore_type() == RestoreType::LAST_SESSION_EXITED_CLEANLY) {
     if (entry.GetHasPostData())
       return FrameMsg_Navigate_Type::RESTORE_WITH_POST;
     return FrameMsg_Navigate_Type::RESTORE;
   }
 
   return FrameMsg_Navigate_Type::NORMAL;
 }
 
 }  // namespace
 
 struct NavigatorImpl::NavigationMetricsData {
   NavigationMetricsData(base::TimeTicks start_time,
                         GURL url,
-                        NavigationEntryImpl::RestoreType restore_type)
+                        RestoreType restore_type)
       : start_time_(start_time), url_(url) {
     is_restoring_from_last_session_ =
-        (restore_type ==
-             NavigationEntryImpl::RESTORE_LAST_SESSION_EXITED_CLEANLY ||
-         restore_type == NavigationEntryImpl::RESTORE_LAST_SESSION_CRASHED);
+        (restore_type == RestoreType::LAST_SESSION_EXITED_CLEANLY ||
+         restore_type == RestoreType::LAST_SESSION_CRASHED);
   }
 
   base::TimeTicks start_time_;
   GURL url_;
   bool is_restoring_from_last_session_;
   base::TimeTicks url_job_start_time_;
   base::TimeDelta before_unload_delay_;
 };
 
 NavigatorImpl::NavigatorImpl(
@@ skipping 158 matching lines @@
     delegate_->DidFailLoadWithError(
         render_frame_host, url, error_code,
         error_description, was_ignored_by_handler);
   }
 }
 
 bool NavigatorImpl::NavigateToEntry(
     FrameTreeNode* frame_tree_node,
     const FrameNavigationEntry& frame_entry,
     const NavigationEntryImpl& entry,
-    NavigationController::ReloadType reload_type,
+    ReloadType reload_type,
     bool is_same_document_history_load,
     bool is_history_navigation_in_new_child,
     bool is_pending_entry,
     const scoped_refptr<ResourceRequestBodyImpl>& post_body) {
   TRACE_EVENT0("browser,navigation", "NavigatorImpl::NavigateToEntry");
 
   GURL dest_url = frame_entry.url();
   Referrer dest_referrer = frame_entry.referrer();
-  if (reload_type ==
-          NavigationController::ReloadType::RELOAD_ORIGINAL_REQUEST_URL &&
+  if (reload_type == ReloadType::ORIGINAL_REQUEST_URL &&
       entry.GetOriginalRequestURL().is_valid() && !entry.GetHasPostData()) {
     // We may have been redirected when navigating to the current URL.
     // Use the URL the user originally intended to visit, if it's valid and if a
     // POST wasn't involved; the latter case avoids issues with sending data to
     // the wrong page.
     dest_url = entry.GetOriginalRequestURL();
     dest_referrer = Referrer();
   }
 
   // Don't attempt to navigate to non-empty invalid URLs.
@@ skipping 21 matching lines @@
       TRACE_EVENT_SCOPE_GLOBAL, navigation_start.ToInternalValue());
 
   // Determine if LoFi should be used for the navigation.
   LoFiState lofi_state = LOFI_UNSPECIFIED;
   if (!frame_tree_node->IsMainFrame()) {
     // For subframes, use the state of the top-level frame.
     lofi_state = frame_tree_node->frame_tree()
                      ->root()
                      ->current_frame_host()
                      ->last_navigation_lofi_state();
-  } else if (reload_type ==
-             NavigationController::ReloadType::RELOAD_DISABLE_LOFI_MODE) {
+  } else if (reload_type == ReloadType::DISABLE_LOFI_MODE) {
     // Disable LoFi when asked for it explicitly.
     lofi_state = LOFI_OFF;
   }
 
   // PlzNavigate: the RenderFrameHosts are no longer asked to navigate.
   if (IsBrowserSideNavigationEnabled()) {
     navigation_data_.reset(new NavigationMetricsData(navigation_start, dest_url,
                                                      entry.restore_type()));
     RequestNavigation(frame_tree_node, dest_url, dest_referrer, frame_entry,
                       entry, reload_type, lofi_state,
@@ skipping 11 matching lines @@
       TRACE_EVENT_ASYNC_BEGIN_WITH_TIMESTAMP1(
           "navigation", "Navigation timeToNetworkStack",
           frame_tree_node->navigation_request()->navigation_handle(),
           navigation_start.ToInternalValue(),
           "FrameTreeNode id", frame_tree_node->frame_tree_node_id());
     }
 
   } else {
     RenderFrameHostImpl* dest_render_frame_host =
         frame_tree_node->render_manager()->Navigate(
-            dest_url, frame_entry, entry,
-            reload_type != NavigationController::NO_RELOAD);
+            dest_url, frame_entry, entry, reload_type != ReloadType::NONE);
     if (!dest_render_frame_host)
       return false;  // Unable to create the desired RenderFrameHost.
 
     // Make sure no code called via RFHM::Navigate clears the pending entry.
     if (is_pending_entry)
       CHECK_EQ(controller_->GetPendingEntry(), &entry);
 
     // For security, we should never send non-Web-UI URLs to a Web UI renderer.
     // Double check that here.
     CheckWebUIRendererDoesNotDisplayNormalURL(dest_render_frame_host, dest_url);
@@ skipping 63 matching lines @@
   // Notify observers about navigation.
   if (delegate_ && is_pending_entry)
     delegate_->DidStartNavigationToPendingEntry(dest_url, reload_type);
 
   return true;
 }
 
 bool NavigatorImpl::NavigateToPendingEntry(
     FrameTreeNode* frame_tree_node,
     const FrameNavigationEntry& frame_entry,
-    NavigationController::ReloadType reload_type,
+    ReloadType reload_type,
     bool is_same_document_history_load) {
   return NavigateToEntry(frame_tree_node, frame_entry,
                          *controller_->GetPendingEntry(), reload_type,
                          is_same_document_history_load, false, true, nullptr);
 }
 
 bool NavigatorImpl::NavigateNewChildFrame(
     RenderFrameHostImpl* render_frame_host,
     const std::string& unique_name) {
   NavigationEntryImpl* entry =
       controller_->GetEntryWithUniqueID(render_frame_host->nav_entry_id());
   if (!entry)
     return false;
 
   // TODO(creis): Remove unique_name from the IPC, now that we can rely on the
   // replication state.
   DCHECK_EQ(render_frame_host->frame_tree_node()->unique_name(), unique_name);
   FrameNavigationEntry* frame_entry =
       entry->GetFrameEntry(render_frame_host->frame_tree_node());
   if (!frame_entry)
     return false;
 
   return NavigateToEntry(render_frame_host->frame_tree_node(), *frame_entry,
-                         *entry, NavigationControllerImpl::NO_RELOAD, false,
-                         true, false, nullptr);
+                         *entry, ReloadType::NONE, false, true, false, nullptr);
 }
 
 void NavigatorImpl::DidNavigate(
     RenderFrameHostImpl* render_frame_host,
     const FrameHostMsg_DidCommitProvisionalLoad_Params& params) {
   FrameTree* frame_tree = render_frame_host->frame_tree_node()->frame_tree();
   bool oopifs_possible = SiteIsolationPolicy::AreCrossProcessFramesPossible();
 
   bool has_embedded_credentials =
       params.url.has_username() || params.url.has_password();
@@ skipping 379 matching lines @@
   // scratch.  This works because we do not depend on |frame_entry| being inside
   // |entry| during NavigateToEntry.  This will go away when we shortcut this
   // further in https://crbug.com/536906.
   scoped_refptr<FrameNavigationEntry> frame_entry(entry->GetFrameEntry(node));
   if (!frame_entry) {
     frame_entry = new FrameNavigationEntry(
         node->unique_name(), -1, -1, nullptr,
         static_cast<SiteInstanceImpl*>(source_site_instance), dest_url,
         referrer_to_use, method, -1);
   }
-  NavigateToEntry(node, *frame_entry, *entry.get(),
-                  NavigationController::NO_RELOAD, false, false, false,
-                  post_body);
+  NavigateToEntry(node, *frame_entry, *entry.get(), ReloadType::NONE, false,
+                  false, false, post_body);
 }
 
 // PlzNavigate
 void NavigatorImpl::OnBeforeUnloadACK(FrameTreeNode* frame_tree_node,
                                       bool proceed) {
   CHECK(IsBrowserSideNavigationEnabled());
   DCHECK(frame_tree_node);
 
   NavigationRequest* navigation_request = frame_tree_node->navigation_request();
 
@@ skipping 127 matching lines @@
   // Only stores the beforeunload delay if we're tracking a browser initiated
   // navigation and it happened later than the navigation request.
   if (navigation_data_ &&
       renderer_before_unload_start_time > navigation_data_->start_time_) {
     navigation_data_->before_unload_delay_ =
         renderer_before_unload_end_time - renderer_before_unload_start_time;
   }
 }
 
 // PlzNavigate
-void NavigatorImpl::RequestNavigation(
-    FrameTreeNode* frame_tree_node,
-    const GURL& dest_url,
-    const Referrer& dest_referrer,
-    const FrameNavigationEntry& frame_entry,
-    const NavigationEntryImpl& entry,
-    NavigationController::ReloadType reload_type,
-    LoFiState lofi_state,
-    bool is_same_document_history_load,
-    bool is_history_navigation_in_new_child,
-    base::TimeTicks navigation_start) {
+void NavigatorImpl::RequestNavigation(FrameTreeNode* frame_tree_node,
+                                      const GURL& dest_url,
+                                      const Referrer& dest_referrer,
+                                      const FrameNavigationEntry& frame_entry,
+                                      const NavigationEntryImpl& entry,
+                                      ReloadType reload_type,
+                                      LoFiState lofi_state,
+                                      bool is_same_document_history_load,
+                                      bool is_history_navigation_in_new_child,
+                                      base::TimeTicks navigation_start) {
   CHECK(IsBrowserSideNavigationEnabled());
   DCHECK(frame_tree_node);
 
   // This value must be set here because creating a NavigationRequest might
   // change the renderer live/non-live status and change this result.
   bool should_dispatch_beforeunload =
       frame_tree_node->current_frame_host()->ShouldDispatchBeforeUnload();
   FrameMsg_Navigate_Type::Value navigation_type =
       GetNavigationType(controller_->GetBrowserContext(), entry, reload_type);
   std::unique_ptr<NavigationRequest> scoped_request =
@@ skipping 25 matching lines @@
 
   // Have the current renderer execute its beforeunload event if needed. If it
   // is not needed (when beforeunload dispatch is not needed or this navigation
   // is synchronous and same-site) then NavigationRequest::BeginNavigation
   // should be directly called instead.
   if (should_dispatch_beforeunload &&
       ShouldMakeNetworkRequestForURL(
           navigation_request->common_params().url)) {
     navigation_request->SetWaitingForRendererResponse();
     frame_tree_node->current_frame_host()->DispatchBeforeUnload(
-        true, reload_type != NavigationController::NO_RELOAD);
+        true, reload_type != ReloadType::NONE);
   } else {
     navigation_request->BeginNavigation();
   }
 }
 
 void NavigatorImpl::RecordNavigationMetrics(
     const LoadCommittedDetails& details,
     const FrameHostMsg_DidCommitProvisionalLoad_Params& params,
     SiteInstance* site_instance) {
   DCHECK(site_instance->HasProcess());
@@ skipping 125 matching lines @@
   if (pending_entry != controller_->GetVisibleEntry() ||
       !should_preserve_entry) {
     controller_->DiscardPendingEntry(true);
 
     // Also force the UI to refresh.
     controller_->delegate()->NotifyNavigationStateChanged(INVALIDATE_TYPE_URL);
   }
 }
 
 }  // namespace content