Move a bunch of code in content\renderer to the content namespace.

content/renderer/render_view_impl.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_RENDERER_RENDER_VIEW_IMPL_H_
 #define CONTENT_RENDERER_RENDER_VIEW_IMPL_H_
 
-#include <deque>
-#include <map>
 #include <set>
-#include <string>
-#include <vector>

[scottmg, 2012/10/19 19:46:35]

yikes

 
 #include "base/basictypes.h"
 #include "base/gtest_prod_util.h"
 #include "base/id_map.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "base/timer.h"
 #include "base/values.h"
 #include "build/build_config.h"
@@ skipping 16 matching lines @@
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebConsoleMessage.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrameClient.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebHistoryItem.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebIconURL.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebInputEvent.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebNavigationType.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebNode.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebPageSerializerClient.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebPageVisibilityState.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebSecurityOrigin.h"
-#include "third_party/WebKit/Source/WebKit/chromium/public/WebTextDirection.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebViewClient.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebFileSystem.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebGraphicsContext3D.h"
 #include "ui/surface/transport_dib.h"
 #include "webkit/glue/webpreferences.h"
 #include "webkit/media/webmediaplayer_delegate.h"
 #include "webkit/plugins/npapi/webplugin_page_delegate.h"
 
 #if defined(OS_ANDROID)
 #include "content/renderer/android/content_detector.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebContentDetectionResult.h"
 #endif
 
 #if defined(COMPILER_MSVC)
 // RenderViewImpl is a diamond-shaped hierarchy, with WebWidgetClient at the
 // root. VS warns when we inherit the WebWidgetClient method implementations
 // from RenderWidget.  It's safe to ignore that warning.
 #pragma warning(disable: 4250)
 #endif
 
 class CommandLine;
-class DeviceOrientationDispatcher;
-class DevToolsAgent;
 class DomAutomationController;
-class ExternalPopupMenu;
-class GeolocationDispatcher;
-class GURL;
 class JavaBridgeDispatcher;
-class LoadProgressTracker;
-class MediaStreamDispatcher;
-class MediaStreamImpl;
-class MouseLockDispatcher;
-class NotificationProvider;
 class PepperDeviceTest;
+class SkBitmap;
+class WebUIBindings;
 struct PP_NetAddress_Private;
-class RenderWidgetFullscreenPepper;
-class RendererWebColorChooserImpl;
-class SkBitmap;
-class InputTagSpeechDispatcher;
-class SpeechRecognitionDispatcher;
 struct ViewMsg_Navigate_Params;
 struct ViewMsg_PostMessage_Params;
 struct ViewMsg_StopFinding_Params;
 struct ViewMsg_SwapOut_Params;
 struct WebDropData;
-class WebIntentsHost;
-class WebPluginDelegateProxy;
-class WebUIBindings;
-
-namespace content {
-class DocumentState;
-class NavigationState;
-class RenderViewObserver;
-class RenderViewTest;
-class RendererAccessibility;
-class RendererPpapiHost;
-#if defined(OS_ANDROID)
-class WebMediaPlayerProxyImplAndroid;
-#endif
-struct CustomContextMenuContext;
-struct FileChooserParams;
-
-namespace old {
-class GuestToEmbedderChannel;
-}
-
-}  // namespace content
-
-namespace gfx {
-class Point;
-class Rect;
-}  // namespace gfx
 
 namespace ui {
 struct SelectedFileInfo;
 }  // namespace ui
 
 namespace webkit {
 
 namespace ppapi {
 class PluginInstance;
 class WebPluginImpl;
@@ skipping 15 matching lines @@
 
 namespace WebKit {
 class WebApplicationCacheHost;
 class WebApplicationCacheHostClient;
 class WebCompositorOutputSurface;
 class WebDOMMessageEvent;
 class WebDataSource;
 class WebDragData;
 class WebGeolocationClient;
 class WebGestureEvent;
-#if defined(OS_ANDROID)
-class WebHitTestResult;
-#endif
 class WebIconURL;
 class WebImage;
 class WebPeerConnection00Handler;
 class WebPeerConnection00HandlerClient;
 class WebMediaPlayer;
 class WebMediaPlayerClient;
 class WebMouseEvent;
 class WebPeerConnectionHandler;
 class WebPeerConnectionHandlerClient;
 class WebSocketStreamHandle;
 class WebSpeechInputController;
 class WebSpeechInputListener;
 class WebSpeechRecognizer;
 class WebStorageNamespace;
 class WebTouchEvent;
 class WebURLRequest;
 class WebUserMediaClient;
 struct WebActiveWheelFlingParameters;
 struct WebFileChooserParams;
 struct WebFindOptions;
 struct WebMediaPlayerAction;
 struct WebPluginAction;
 struct WebPoint;
 struct WebWindowFeatures;
+
+#if defined(OS_ANDROID)
+class WebHitTestResult;
+#endif
+}
+
+namespace content {
+class DeviceOrientationDispatcher;
+class DevToolsAgent;
+class DocumentState;
+class ExternalPopupMenu;
+class GeolocationDispatcher;
+class InputTagSpeechDispatcher;
+class LoadProgressTracker;
+class MediaStreamDispatcher;
+class MediaStreamImpl;
+class MouseLockDispatcher;
+class NavigationState;
+class NotificationProvider;
+class RenderViewObserver;
+class RenderViewTest;
+class RendererAccessibility;
+class RendererPpapiHost;
+class RendererWebColorChooserImpl;
+class RenderWidgetFullscreenPepper;
+class SpeechRecognitionDispatcher;
+class WebIntentsHost;
+class WebPluginDelegateProxy;
+struct CustomContextMenuContext;
+struct FileChooserParams;
+
+#if defined(OS_ANDROID)
+class WebMediaPlayerProxyImplAndroid;
+#endif
+
+namespace old {
+class GuestToEmbedderChannel;
 }
 
 // We need to prevent a page from trying to create infinite popups. It is not
 // as simple as keeping a count of the number of immediate children
 // popups. Having an html file that window.open()s itself would create
 // an unlimited chain of RenderViews who only have one RenderView child.
 //
 // Therefore, each new top level RenderView creates a new counter and shares it
 // with all its children and grandchildren popup RenderViewImpls created with
 // createView() to have a sort of global limit for the page so no more than
 // kMaximumNumberOfPopups popups are created.
 //
 // This is a RefCounted holder of an int because I can't say
 // scoped_refptr<int>.
 typedef base::RefCountedData<int> SharedRenderViewCounter;
 
 //
 // RenderView is an object that manages a WebView object, and provides a
 // communication interface with an embedding application process
 //
 class RenderViewImpl : public RenderWidget,
                        public WebKit::WebViewClient,
                        public WebKit::WebFrameClient,
                        public WebKit::WebPageSerializerClient,
-                       public content::RenderView,
+                       public RenderView,
                        public webkit::npapi::WebPluginPageDelegate,
                        public webkit_media::WebMediaPlayerDelegate,
                        public WebGraphicsContext3DSwapBuffersClient,
                        public base::SupportsWeakPtr<RenderViewImpl> {
  public:
   // Creates a new RenderView.  The parent_hwnd specifies a HWND to use as the
   // parent of the WebView HWND that will be created.  If this is a blocked
   // popup or as a new tab, opener_id is the routing ID of the RenderView
   // responsible for creating this RenderView (corresponding to parent_hwnd).
   // |counter| is either a currently initialized counter, or NULL (in which case
   // we treat this RenderView as a top level window).
   CONTENT_EXPORT static RenderViewImpl* Create(
       gfx::NativeViewId parent_hwnd,
       int32 opener_id,
-      const content::RendererPreferences& renderer_prefs,
+      const RendererPreferences& renderer_prefs,
       const webkit_glue::WebPreferences& webkit_prefs,
       SharedRenderViewCounter* counter,
       int32 routing_id,
       int32 surface_id,
       int64 session_storage_namespace_id,
       const string16& frame_name,
       bool is_renderer_created,
       bool swapped_out,
       int32 next_page_id,
       const WebKit::WebScreenInfo& screen_info,
-      content::old::GuestToEmbedderChannel* guest_to_embedder_channel,
+      old::GuestToEmbedderChannel* guest_to_embedder_channel,
       AccessibilityMode accessibility_mode);
 
   // Returns the RenderViewImpl containing the given WebView.
   CONTENT_EXPORT static RenderViewImpl* FromWebView(WebKit::WebView* webview);
 
   // May return NULL when the view is closing.
   CONTENT_EXPORT WebKit::WebView* webview() const;
 
   // WebGraphicsContext3DSwapBuffersClient implementation.
 
@@ skipping 25 matching lines @@
     return mouse_lock_dispatcher_;
   }
 
 #if defined(OS_ANDROID)
   webkit_media::WebMediaPlayerManagerAndroid* media_player_manager() {
     return media_player_manager_.get();
   }
 #endif
 
   // Functions to add and remove observers for this object.
-  void AddObserver(content::RenderViewObserver* observer);
-  void RemoveObserver(content::RenderViewObserver* observer);
+  void AddObserver(RenderViewObserver* observer);
+  void RemoveObserver(RenderViewObserver* observer);
 
   // Adds the given file chooser request to the file_chooser_completion_ queue
   // (see that var for more) and requests the chooser be displayed if there are
   // no other waiting items in the queue.
   //
   // Returns true if the chooser was successfully scheduled. False means we
   // didn't schedule anything.
-  bool ScheduleFileChooser(const content::FileChooserParams& params,
+  bool ScheduleFileChooser(const FileChooserParams& params,
                            WebKit::WebFileChooserCompletion* completion);
 
   // Sets whether  the renderer should report load progress to the browser.
   void SetReportLoadProgressEnabled(bool enabled);
 
-  content::old::GuestToEmbedderChannel* GetGuestToEmbedderChannel() const;
-  void SetGuestToEmbedderChannel(content::old::GuestToEmbedderChannel* channel);
+  old::GuestToEmbedderChannel* GetGuestToEmbedderChannel() const;
+  void SetGuestToEmbedderChannel(old::GuestToEmbedderChannel* channel);
   PP_Instance guest_pp_instance() const { return guest_pp_instance_; }
   void set_guest_pp_instance(PP_Instance instance) {
     guest_pp_instance_ = instance;
   }
   void set_guest_graphics_resource(const ppapi::HostResource& resource) {
     guest_graphics_resource_ = resource;
   }
   const ppapi::HostResource& guest_graphics_resource() const {
     return guest_graphics_resource_;
   }
@@ skipping 32 matching lines @@
   void PpapiPluginTextInputTypeChanged();
   void PpapiPluginCaretPositionChanged();
 
   // Cancels current composition.
   void PpapiPluginCancelComposition();
 
   // Informs the render view that a PPAPI plugin has changed selection.
   void PpapiPluginSelectionChanged();
 
   // Notification that a PPAPI plugin has been created.
-  void PpapiPluginCreated(content::RendererPpapiHost* host);
+  void PpapiPluginCreated(RendererPpapiHost* host);
 
   // Retrieves the current caret position if a PPAPI plugin has focus.
   bool GetPpapiPluginCaretBounds(gfx::Rect* rect);
 
   // Simulates IME events for testing purpose.
   void SimulateImeSetComposition(
       const string16& text,
       const std::vector<WebKit::WebCompositionUnderline>& underlines,
       int selection_start,
       int selection_end);
@@ skipping 329 matching lines @@
       WebKit::WebFrame* frame,
       const WebKit::WebURL& url) OVERRIDE;
 
   // WebKit::WebPageSerializerClient implementation ----------------------------
 
   virtual void didSerializeDataForFrame(
       const WebKit::WebURL& frame_url,
       const WebKit::WebCString& data,
       PageSerializationStatus status) OVERRIDE;
 
-  // content::RenderView implementation ----------------------------------------
+  // RenderView implementation -------------------------------------------------
 
   virtual bool Send(IPC::Message* message) OVERRIDE;
   virtual int GetRoutingID() const OVERRIDE;
   virtual int GetPageId() const OVERRIDE;
   virtual gfx::Size GetSize() const OVERRIDE;
   virtual webkit_glue::WebPreferences& GetWebkitPreferences() OVERRIDE;
   virtual WebKit::WebView* GetWebView() OVERRIDE;
   virtual WebKit::WebNode GetFocusedNode() const OVERRIDE;
   virtual WebKit::WebNode GetContextMenuNode() const OVERRIDE;
   virtual bool IsEditableNode(const WebKit::WebNode& node) const OVERRIDE;
   virtual WebKit::WebPlugin* CreatePlugin(
       WebKit::WebFrame* frame,
       const webkit::WebPluginInfo& info,
       const WebKit::WebPluginParams& params) OVERRIDE;
   virtual void EvaluateScript(const string16& frame_xpath,
                               const string16& jscript,
                               int id,
                               bool notify_result) OVERRIDE;
   virtual bool ShouldDisplayScrollbars(int width, int height) const OVERRIDE;
   virtual int GetEnabledBindings() const OVERRIDE;
   virtual bool GetContentStateImmediately() const OVERRIDE;
   virtual float GetFilteredTimePerFrame() const OVERRIDE;
-  virtual int ShowContextMenu(
-      content::ContextMenuClient* client,
-      const content::ContextMenuParams& params) OVERRIDE;
+  virtual int ShowContextMenu(ContextMenuClient* client,
+                              const ContextMenuParams& params) OVERRIDE;
   virtual void CancelContextMenu(int request_id) OVERRIDE;
   virtual WebKit::WebPageVisibilityState GetVisibilityState() const OVERRIDE;
   virtual void RunModalAlertDialog(WebKit::WebFrame* frame,
                                    const WebKit::WebString& message) OVERRIDE;
   virtual void LoadURLExternally(
       WebKit::WebFrame* frame,
       const WebKit::WebURLRequest& request,
       WebKit::WebNavigationPolicy policy) OVERRIDE;
   virtual void Repaint(const gfx::Size& size) OVERRIDE;
 
@@ skipping 66 matching lines @@
       std::vector<gfx::Rect>* character_bounds) OVERRIDE;
   virtual bool CanComposeInline() OVERRIDE;
   virtual bool WebWidgetHandlesCompositorScheduling() const OVERRIDE;
 
  private:
   // For unit tests.
   friend class ExternalPopupMenuTest;
   friend class PepperDeviceTest;
   friend class RendererAccessibilityTest;
   friend class WebIntentsHostTest;
-  friend class content::RenderViewTest;
+  friend class RenderViewTest;
 
   FRIEND_TEST_ALL_PREFIXES(ExternalPopupMenuRemoveTest, RemoveOnChange);
   FRIEND_TEST_ALL_PREFIXES(ExternalPopupMenuTest, NormalCase);
   FRIEND_TEST_ALL_PREFIXES(ExternalPopupMenuTest, ShowPopupThenNavigate);
   FRIEND_TEST_ALL_PREFIXES(RenderViewImplTest, DecideNavigationPolicyForWebUI);
   FRIEND_TEST_ALL_PREFIXES(RenderViewImplTest,
                            DontIgnoreBackAfterNavEntryLimit);
   FRIEND_TEST_ALL_PREFIXES(RenderViewImplTest, ImeComposition);
   FRIEND_TEST_ALL_PREFIXES(RenderViewImplTest, InsertCharacters);
   FRIEND_TEST_ALL_PREFIXES(RenderViewImplTest, JSBlockSentAfterPageLoad);
@@ skipping 22 matching lines @@
   typedef std::map<GURL, double> HostZoomLevels;
 
   enum ErrorPageType {
     DNS_ERROR,
     HTTP_404,
     CONNECTION_ERROR,
   };
 
   RenderViewImpl(gfx::NativeViewId parent_hwnd,
                  int32 opener_id,
-                 const content::RendererPreferences& renderer_prefs,
+                 const RendererPreferences& renderer_prefs,
                  const webkit_glue::WebPreferences& webkit_prefs,
                  SharedRenderViewCounter* counter,
                  int32 routing_id,
                  int32 surface_id,
                  int64 session_storage_namespace_id,
                  const string16& frame_name,
                  bool is_renderer_created,
                  bool swapped_out,
                  int32 next_page_id,
                  const WebKit::WebScreenInfo& screen_info,
-                 content::old::GuestToEmbedderChannel*
-                    guest_to_embedder_channel,
+                 old::GuestToEmbedderChannel* guest_to_embedder_channel,
                  AccessibilityMode accessibility_mode);
 
   // Do not delete directly.  This class is reference counted.
   virtual ~RenderViewImpl();
 
   void UpdateURL(WebKit::WebFrame* frame);
   void UpdateTitle(WebKit::WebFrame* frame, const string16& title,
                    WebKit::WebTextDirection title_direction);
   void UpdateSessionHistory(WebKit::WebFrame* frame);
   void SendUpdateState(const WebKit::WebHistoryItem& item);
 
   // Update current main frame's encoding and send it to browser window.
   // Since we want to let users see the right encoding info from menu
   // before finishing loading, we call the UpdateEncoding in
   // a) function:DidCommitLoadForFrame. When this function is called,
   // that means we have got first data. In here we try to get encoding
   // of page if it has been specified in http header.
   // b) function:DidReceiveTitle. When this function is called,
   // that means we have got specified title. Because in most of webpages,
   // title tags will follow meta tags. In here we try to get encoding of
   // page if it has been specified in meta tag.
   // c) function:DidFinishDocumentLoadForFrame. When this function is
   // called, that means we have got whole html page. In here we should
   // finally get right encoding of page.
   void UpdateEncoding(WebKit::WebFrame* frame,
                       const std::string& encoding_name);
 
   void OpenURL(WebKit::WebFrame* frame,
                const GURL& url,
-               const content::Referrer& referrer,
+               const Referrer& referrer,
                WebKit::WebNavigationPolicy policy);
 
-  bool RunJavaScriptMessage(content::JavaScriptMessageType type,
+  bool RunJavaScriptMessage(JavaScriptMessageType type,
                             const string16& message,
                             const string16& default_value,
                             const GURL& frame_url,
                             string16* result);
 
   // Sends a message and runs a nested message loop.
   bool SendAndRunNestedMessageLoop(IPC::SyncMessage* message);
 
   // Called when the "pinned to left/right edge" state needs to be updated.
   void UpdateScrollState(WebKit::WebFrame* frame);
 
   // IPC message handlers ------------------------------------------------------
   //
   // The documentation for these functions should be in
   // render_messages_internal.h for the message that the function is handling.
 
   CONTENT_EXPORT void OnAllowBindings(int enabled_bindings_flags);
   void OnAllowScriptToClose(bool script_can_close);
   void OnAsyncFileOpened(base::PlatformFileError error_code,
                          IPC::PlatformFileForTransit file_for_transit,
                          int message_id);
   void OnPpapiBrokerChannelCreated(int request_id,
                                    const IPC::ChannelHandle& handle);
   void OnPpapiBrokerPermissionResult(int request_id, bool result);
   void OnCancelDownload(int32 download_id);
   void OnClearFocusedNode();
   void OnClosePage();
-  void OnContextMenuClosed(
-      const content::CustomContextMenuContext& custom_context);
+  void OnContextMenuClosed(const CustomContextMenuContext& custom_context);
   void OnCopy();
   void OnCopyImageAt(int x, int y);
   void OnCut();
   void OnCSSInsertRequest(const string16& frame_xpath,
                           const std::string& css);
-  void OnCustomContextMenuAction(
-      const content::CustomContextMenuContext& custom_context,
-      unsigned action);
+  void OnCustomContextMenuAction(const CustomContextMenuContext& custom_context,
+                                 unsigned action);
   void OnDelete();
   void OnDeterminePageLanguage();
   void OnDisableScrollbarsForSmallWindows(
       const gfx::Size& disable_scrollbars_size_limit);
   void OnDisassociateFromPopupCount();
   void OnDragSourceEndedOrMoved(const gfx::Point& client_point,
                                 const gfx::Point& screen_point,
                                 bool ended,
                                 WebKit::WebDragOperation drag_operation);
   void OnDragSourceSystemDragEnded();
@@ skipping 60 matching lines @@
   void OnSetNavigationStartTime(
       const base::TimeTicks& browser_navigation_start);
   void OnSetWebUIProperty(const std::string& name, const std::string& value);
   CONTENT_EXPORT void OnSetEditCommandsForNextKeyEvent(
       const EditCommands& edit_commands);
   CONTENT_EXPORT void OnSetHistoryLengthAndPrune(int history_length,
                                                  int32 minimum_page_id);
   void OnSetInitialFocus(bool reverse);
   void OnScrollFocusedEditableNodeIntoRect(const gfx::Rect& rect);
   void OnSetPageEncoding(const std::string& encoding_name);
-  void OnSetRendererPrefs(const content::RendererPreferences& renderer_prefs);
+  void OnSetRendererPrefs(const RendererPreferences& renderer_prefs);
   void OnSetZoomLevel(double zoom_level);
   CONTENT_EXPORT void OnSetZoomLevelForLoadingURL(const GURL& url,
                                                   double zoom_level);
   void OnExitFullscreen();
   void OnShouldClose();
   void OnStop();
-  void OnStopFinding(content::StopFindAction action);
+  void OnStopFinding(StopFindAction action);
   CONTENT_EXPORT void OnSwapOut(const ViewMsg_SwapOut_Params& params);
   void OnThemeChanged();
   void OnUndo();
   void OnUpdateTargetURLAck();
   void OnUpdateTimezone();
   CONTENT_EXPORT void OnUpdateWebPreferences(
       const webkit_glue::WebPreferences& prefs);
   CONTENT_EXPORT void OnUnselect();
 
-  void OnZoom(content::PageZoom zoom);
-  void OnZoomFactor(content::PageZoom zoom, int zoom_center_x,
-                    int zoom_center_y);
+  void OnZoom(PageZoom zoom);
+  void OnZoomFactor(PageZoom zoom, int zoom_center_x, int zoom_center_y);
 
   void OnEnableViewSourceMode();
 
   void OnJavaBridgeInit();
 
   void OnUpdatedFrameTree(int process_id,
                           int route_id,
                           const std::string& frame_tree);
 
 #if defined(OS_ANDROID)
@@ skipping 14 matching lines @@
   void OnSetWindowVisibility(bool visible);
   void OnWindowFrameChanged(const gfx::Rect& window_frame,
                             const gfx::Rect& view_frame);
 #endif
 
 
   // Adding a new message handler? Please add it in alphabetical order above
   // and put it in the same position in the .cc file.
 
   // Misc private functions ----------------------------------------------------
-  void ZoomFactorHelper(content::PageZoom zoom, int zoom_center_x,
-                        int zoom_center_y, float scaling_increment);
+  void ZoomFactorHelper(PageZoom zoom, int zoom_center_x, int zoom_center_y,
+                        float scaling_increment);
 
   void AltErrorPageFinished(WebKit::WebFrame* frame,
                             const WebKit::WebURLError& original_error,
                             const std::string& html);
 
   // Check whether the preferred size has changed.
   void CheckPreferredSize();
 
   WebKit::WebGraphicsContext3D* CreateGraphicsContext3D(
       const WebKit::WebGraphicsContext3D::Attributes& attributes);
@@ skipping 69 matching lines @@
 
   bool MaybeLoadAlternateErrorPage(WebKit::WebFrame* frame,
                                    const WebKit::WebURLError& error,
                                    bool replace);
 
   // Make this RenderView show an empty, unscriptable page.
   void NavigateToSwappedOutURL(WebKit::WebFrame* frame);
 
   // If we initiated a navigation, this function will populate |document_state|
   // with the navigation information saved in OnNavigate().
-  void PopulateDocumentStateFromPending(content::DocumentState* document_state);
+  void PopulateDocumentStateFromPending(DocumentState* document_state);
 
   // Returns a new NavigationState populated with the navigation information
   // saved in OnNavigate().
-  content::NavigationState* CreateNavigationStateFromPending();
+  NavigationState* CreateNavigationStateFromPending();
 
   // Processes the command-line flags --enable-viewport and
   // --enable-fixed-layout[=w,h].
   void ProcessViewLayoutFlags(const CommandLine& command_line);
 
   // Processes the command-line flags --enable-pinch and
   // --enable-pinch-in-compositor
   void ProcessAcceleratedPinchZoomFlags(const CommandLine& command_line);
 
   // Sends a reply to the current find operation handling if it was a
   // synchronous find request.
   void SendFindReply(int request_id,
                      int match_count,
                      int ordinal,
                      const WebKit::WebRect& selection_rect,
                      bool final_status_update);
 
   // Starts nav_state_sync_timer_ if it isn't already running.
   void StartNavStateSyncTimerIfNecessary();
 
   // Stops the current find-in-page search.
-  void StopFinding(content::StopFindAction action);
+  void StopFinding(StopFindAction action);
 
   // Dispatches the current navigation state to the browser. Called on a
   // periodic timer so we don't send too many messages.
   void SyncNavigationState();
 
   // Dispatches the current state of selection on the webpage to the browser if
   // it has changed.
   // TODO(varunjain): delete this method once we figure out how to keep
   // selection handles in sync with the webpage.
   void SyncSelectionIfRequired();
 
 #if defined(OS_POSIX) && !defined(OS_MACOSX)
   void UpdateFontRenderingFromRendererPrefs();
 #else
   void UpdateFontRenderingFromRendererPrefs() {}
 #endif
 
   // Update the target url and tell the browser that the target URL has changed.
   // If |url| is empty, show |fallback_url|.
   void UpdateTargetURL(const GURL& url, const GURL& fallback_url);
 
   // ---------------------------------------------------------------------------
   // ADDING NEW FUNCTIONS? Please keep private functions alphabetized and put
   // it in the same order in the .cc file as it was in the header.
   // ---------------------------------------------------------------------------
 
   // Settings ------------------------------------------------------------------
 
   webkit_glue::WebPreferences webkit_preferences_;
-  content::RendererPreferences renderer_preferences_;
+  RendererPreferences renderer_preferences_;
 
   HostZoomLevels host_zoom_levels_;
 
   // Whether content state (such as form state, scroll position and page
   // contents) should be sent to the browser immediately. This is normally
   // false, but set to true by some tests.
   bool send_content_state_immediately_;
 
   // Bitwise-ORed set of extra bindings that have been enabled.  See
   // BindingsPolicy for details.
@@ skipping 30 matching lines @@
 
   // Whether this RenderView was created by a frame that was suppressing its
   // opener. If so, we may want to load pages in a separate process.  See
   // decidePolicyForNavigation for details.
   bool opener_suppressed_;
 
   // If we are handling a top-level client-side redirect, this tracks the URL
   // of the page that initiated it. Specifically, when a load is committed this
   // is used to determine if that load originated from a client-side redirect.
   // It is empty if there is no top-level client-side redirect.
-  content::Referrer completed_client_redirect_src_;
+  Referrer completed_client_redirect_src_;
 
   // Holds state pertaining to a navigation that we initiated.  This is held by
   // the WebDataSource::ExtraData attribute.  We use pending_navigation_state_
   // as a temporary holder for the state until the WebDataSource corresponding
   // to the new navigation is created.  See DidCreateDataSource.
   scoped_ptr<ViewMsg_Navigate_Params> pending_navigation_params_;
 
   // Timer used to delay the updating of nav state (see SyncNavigationState).
   base::OneShotTimer<RenderViewImpl> nav_state_sync_timer_;
 
   // Page IDs ------------------------------------------------------------------
-  // See documentation in content::RenderView.
+  // See documentation in RenderView.
   int32 page_id_;
 
   // Indicates the ID of the last page that we sent a FrameNavigate to the
   // browser for. This is used to determine if the most recent transition
   // generated a history entry (less than page_id_), or not (equal to or
   // greater than). Note that this will be greater than page_id_ if the user
   // goes back.
   int32 last_page_id_sent_to_browser_;
 
   // The next available page ID to use for this RenderView.  These IDs are
@@ skipping 61 matching lines @@
   // (WebKit-originated) context menu events will have an ID of 0 and will not
   // be in this map.
   //
   // We don't want to add internal ones since some of the "special" page
   // handlers in the browser process just ignore the context menu requests so
   // avoid showing context menus, and so this will cause right clicks to leak
   // entries in this map. Most users of the custom context menu (e.g. Pepper
   // plugins) are normally only on "regular" pages and the regular pages will
   // always respond properly to the request, so we don't have to worry so
   // much about leaks.
-  IDMap<content::ContextMenuClient, IDMapExternalPointer>
-      pending_context_menus_;
+  IDMap<ContextMenuClient, IDMapExternalPointer> pending_context_menus_;
 
   // View ----------------------------------------------------------------------
 
   // Cache the preferred size of the page in order to prevent sending the IPC
   // when layout() recomputes but doesn't actually change sizes.
   gfx::Size preferred_size_;
 
   // Used to delay determining the preferred size (to avoid intermediate
   // states for the sizes).
   base::OneShotTimer<RenderViewImpl> check_preferred_size_timer_;
@@ skipping 47 matching lines @@
   // MediaStreamImpl attached to this view; lazily initialized.
   MediaStreamImpl* media_stream_impl_;
 
   DevToolsAgent* devtools_agent_;
 
   // The current accessibility mode.
   AccessibilityMode accessibility_mode_;
 
   // Only valid if |accessibility_mode_| is anything other than
   // AccessibilityModeOff.
-  content::RendererAccessibility* renderer_accessibility_;
+  RendererAccessibility* renderer_accessibility_;
 
   // Java Bridge dispatcher attached to this view; lazily initialized.
   JavaBridgeDispatcher* java_bridge_dispatcher_;
 
   // Mouse Lock dispatcher attached to this view.
   MouseLockDispatcher* mouse_lock_dispatcher_;
 
 #if defined(OS_ANDROID)
   // Android Specific ---------------------------------------------------------
 
   // Expected id of the next content intent launched. Used to prevent scheduled
   // intents to be launched if aborted.
   size_t expected_content_intent_id_;
 
   // List of click-based content detectors.
-  typedef std::vector< linked_ptr<content::ContentDetector> >
-      ContentDetectorList;
+  typedef std::vector< linked_ptr<ContentDetector> > ContentDetectorList;
   ContentDetectorList content_detectors_;
 
   // Proxy class for WebMediaPlayer to communicate with the real media player
   // objects in browser process.
-  content::WebMediaPlayerProxyImplAndroid* media_player_proxy_;
+  WebMediaPlayerProxyImplAndroid* media_player_proxy_;
 
   // The media player manager for managing all the media players on this view.
   scoped_ptr<webkit_media::WebMediaPlayerManagerAndroid> media_player_manager_;
 
   // Resource manager for all the android media player objects if they are
   // created in the renderer process.
   scoped_ptr<webkit_media::MediaPlayerBridgeManagerImpl> media_bridge_manager_;
 
   // Holds the message used to return find results to the browser during
   // synchronous find-in-page requests. Only non-null during these requests.
@@ skipping 44 matching lines @@
   scoped_ptr<ExternalPopupMenu> external_popup_menu_;
 
   // The node that the context menu was pressed over.
   WebKit::WebNode context_menu_node_;
 
   // Reports load progress to the browser.
   scoped_ptr<LoadProgressTracker> load_progress_tracker_;
 
   // All the registered observers.  We expect this list to be small, so vector
   // is fine.
-  ObserverList<content::RenderViewObserver> observers_;
+  ObserverList<RenderViewObserver> observers_;
 
   // Used to inform didChangeSelection() when it is called in the context
   // of handling a ViewMsg_SelectRange IPC.
   bool handling_select_range_;
 
   // Wraps the |webwidget_| as a MouseLockDispatcher::LockTarget interface.
   scoped_ptr<MouseLockDispatcher::LockTarget> webwidget_mouse_lock_target_;
 
   // Plugins -------------------------------------------------------------------
 
   // All the currently active plugin delegates for this RenderView; kept so
   // that we can enumerate them to send updates about things like window
   // location or tab focus and visibily. These are non-owning references.
   std::set<WebPluginDelegateProxy*> plugin_delegates_;
 
 #if defined(OS_WIN)
   // The ID of the focused NPAPI plug-in.
   int focused_plugin_id_;
 #endif
 
   // Allows JS to access DOM automation. The JS object is only exposed when the
   // DOM automation bindings are enabled.
   scoped_ptr<DomAutomationController> dom_automation_controller_;
 
   // Channel for communication with embedding renderer, if it exists.
-  scoped_refptr<content::old::GuestToEmbedderChannel>
-      guest_to_embedder_channel_;
+  scoped_refptr<old::GuestToEmbedderChannel> guest_to_embedder_channel_;
 
   // The pepper instance identifer for this guest RenderView.
   PP_Instance guest_pp_instance_;
 
   // The ppapi::HostResource associated with the on-screen context for this
   // guest RenderView.
   ppapi::HostResource guest_graphics_resource_;
 
   // This graphics context is initialized once GuestReady() is called.
   WebGraphicsContext3DCommandBufferImpl* guest_uninitialized_context_;
@@ skipping 25 matching lines @@
   // For further details, see the comments on ViewHostMsg_FrameTreeUpdated.
   int target_process_id_;
   int target_routing_id_;
 
   // A map of the current process's frame ids to ids in the remote active render
   // view, if this is a swapped out render view.
   std::map<int, int> active_frame_id_map_;
 
   // NOTE: pepper_delegate_ should be last member because its constructor calls
   // AddObservers method of RenderViewImpl from c-tor.
-  content::PepperPluginDelegateImpl pepper_delegate_;
+  PepperPluginDelegateImpl pepper_delegate_;
 
   // ---------------------------------------------------------------------------
   // ADDING NEW DATA? Please see if it fits appropriately in one of the above
   // sections rather than throwing it randomly at the end. If you're adding a
   // bunch of stuff, you should probably create a helper class and put your
   // data and methods on that to avoid bloating RenderView more.  You can
   // use the Observer interface to filter IPC messages and receive frame change
   // notifications.
   // ---------------------------------------------------------------------------
 
   DISALLOW_COPY_AND_ASSIGN(RenderViewImpl);
 };
 
+}  // namespace content
+
 #endif  // CONTENT_RENDERER_RENDER_VIEW_IMPL_H_