content: Move more two url constants to content namespace.

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 <string>
 #include <vector>
@@ skipping 1372 matching lines @@
 
   const WebHistoryItem& item =
       webview()->mainFrame()->previousHistoryItem();
   SendUpdateState(item);
 }
 
 void RenderViewImpl::SendUpdateState(const WebHistoryItem& item) {
   if (item.isNull())
     return;
 
-  // Don't send state updates for chrome::kSwappedOutURL.
-  if (item.urlString() == WebString::fromUTF8(chrome::kSwappedOutURL))
+  // Don't send state updates for content::kSwappedOutURL.
+  if (item.urlString() == WebString::fromUTF8(content::kSwappedOutURL))
     return;
 
   Send(new ViewHostMsg_UpdateState(
       routing_id_, page_id_, webkit_glue::HistoryItemToString(item)));
 }
 
 void RenderViewImpl::OpenURL(WebFrame* frame,
                              const GURL& url,
                              const Referrer& referrer,
                              WebNavigationPolicy policy) {
@@ skipping 18 matching lines @@
 
   if (!html.empty()) {
     error_html = &html;
   } else {
     content::GetContentClient()->renderer()->GetNavigationErrorStrings(
         failed_request, error, &alt_html, NULL);
     error_html = &alt_html;
   }
 
   frame->loadHTMLString(*error_html,
-                        GURL(chrome::kUnreachableWebDataURL),
+                        GURL(content::kUnreachableWebDataURL),
                         error.unreachableURL,
                         replace);
 }
 
 bool RenderViewImpl::RunJavaScriptMessage(ui::JavascriptMessageType type,
                                           const string16& message,
                                           const string16& default_value,
                                           const GURL& frame_url,
                                           string16* result) {
   bool success = false;
@@ skipping 830 matching lines @@
 }
 
 WebNavigationPolicy RenderViewImpl::decidePolicyForNavigation(
     WebFrame* frame, const WebURLRequest& request, WebNavigationType type,
     const WebNode&, WebNavigationPolicy default_policy, bool is_redirect) {
   Referrer referrer(
       GURL(request.httpHeaderField(WebString::fromUTF8("Referer"))),
       GetReferrerPolicyFromRequest(request));
 
   if (is_swapped_out_) {
-    if (request.url() != GURL(chrome::kSwappedOutURL)) {
+    if (request.url() != GURL(content::kSwappedOutURL)) {
       // Targeted links may try to navigate a swapped out frame.  Allow the
       // browser process to navigate the tab instead.  Note that it is also
       // possible for non-targeted navigations (from this view) to arrive
       // here just after we are swapped out.  It's ok to send them to the
       // browser, as long as they're for the top level frame.
       // TODO(creis): Ensure this supports targeted form submissions when
       // fixing http://crbug.com/101395.
       if (frame->parent() == NULL) {
         OpenURL(frame, request.url(), referrer, default_policy);
         return WebKit::WebNavigationPolicyIgnore;  // Suppress the load here.
       }
 
       // We should otherwise ignore in-process iframe navigations, if they
       // arrive just after we are swapped out.
       return WebKit::WebNavigationPolicyIgnore;
     }
 
-    // Allow chrome::kSwappedOutURL to complete.
+    // Allow content::kSwappedOutURL to complete.
     return default_policy;
   }
 
   // Webkit is asking whether to navigate to a new URL.
   // This is fine normally, except if we're showing UI from one security
   // context and they're trying to navigate to a different context.
   const GURL& url = request.url();
 
   // A content initiated navigation may have originated from a link-click,
   // script, drag-n-drop operation, etc.
@@ skipping 533 matching lines @@
     document_state->set_commit_load_time(Time::Now());
 
   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_++;
 
-    // Don't update history_page_ids_ (etc) for chrome::kSwappedOutURL, since
+    // Don't update history_page_ids_ (etc) for content::kSwappedOutURL, since
     // we don't want to forget the entry that was there, and since we will
-    // never come back to chrome::kSwappedOutURL.  Note that we have to call
+    // never come back to content::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(frame) != GURL(chrome::kSwappedOutURL)) {
+    if (GetLoadingUrl(frame) != GURL(content::kSwappedOutURL)) {
       // Advance our offset in session history, applying the length limit.
       // There is now no forward history.
       history_list_offset_++;
       if (history_list_offset_ >= content::kMaxSessionHistoryEntries)
         history_list_offset_ = content::kMaxSessionHistoryEntries - 1;
       history_list_length_ = history_list_offset_ + 1;
       history_page_ids_.resize(history_list_length_, -1);
       history_page_ids_[history_list_offset_] = page_id_;
     }
   } else {
@@ skipping 1567 matching lines @@
 
     // Send an UpdateState message before we get swapped out.
     SyncNavigationState();
 
     // Synchronously run the unload handler before sending the ACK.
     webview()->dispatchUnloadEvent();
 
     // Swap out and stop sending any IPC messages that are not ACKs.
     SetSwappedOut(true);
 
-    // Replace the page with a blank dummy URL.  The unload handler will not be
+    // Replace the page with a blank dummy URL. The unload handler will not be
     // run a second time, thanks to a check in FrameLoader::stopLoading.
     // We use loadRequest instead of loadHTMLString because the former commits
     // synchronously.  Otherwise a new navigation can interrupt the navigation
-    // to chrome::kSwappedOutURL.  If that happens to be to the page we had been
+    // to content::kSwappedOutURL. If that happens to be to the page we had been
     // showing, then WebKit will never send a commit and we'll be left spinning.
     // TODO(creis): Need to add a better way to do this that avoids running the
-    // beforeunload handler.  For now, we just run it a second time silently.
-    GURL swappedOutURL(chrome::kSwappedOutURL);
+    // beforeunload handler. For now, we just run it a second time silently.
+    GURL swappedOutURL(content::kSwappedOutURL);
     WebURLRequest request(swappedOutURL);
     webview()->mainFrame()->loadRequest(request);
   }
 
   // Just echo back the params in the ACK.
   Send(new ViewHostMsg_SwapOut_ACK(routing_id_, params));
 }
 
 void RenderViewImpl::OnClosePage() {
   FOR_EACH_OBSERVER(RenderViewObserver, observers_, ClosePage());
@@ skipping 52 matching lines @@
   }
 
   const GURL& error_page_url = GetAlternateErrorPageURL(error.unreachableURL,
       ec == net::ERR_NAME_NOT_RESOLVED ? DNS_ERROR : CONNECTION_ERROR);
   if (!error_page_url.is_valid())
     return false;
 
   // 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(chrome::kUnreachableWebDataURL),
+                        GURL(content::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(
       new AltErrorPageResourceFetcher(
@@ skipping 708 matching lines @@
 bool RenderViewImpl::WebWidgetHandlesCompositorScheduling() const {
   return !!RenderThreadImpl::current()->compositor_thread();
 }
 
 void RenderViewImpl::OnJavaBridgeInit() {
   DCHECK(!java_bridge_dispatcher_.get());
 #if defined(ENABLE_JAVA_BRIDGE)
   java_bridge_dispatcher_.reset(new JavaBridgeDispatcher(this));
 #endif
 }