Move Render(View|Widget)Host and associated classes to content namespace.

content/public/browser/render_view_host.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_BROWSER_RENDER_VIEW_HOST_H_
 #define CONTENT_PUBLIC_BROWSER_RENDER_VIEW_HOST_H_
 #pragma once
 
 #include "base/values.h"
 #include "content/common/content_export.h"
 #include "content/public/browser/render_widget_host.h"
 #include "content/public/common/page_zoom.h"
 #include "content/public/common/stop_find_action.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDragOperation.h"
 
 class FilePath;
 class GURL;
 struct WebDropData;
 struct WebPreferences;
 
-namespace content {
-class RenderViewHostDelegate;
-class SessionStorageNamespace;
-class SiteInstance;
-struct CustomContextMenuContext;
-}
-
 namespace gfx {
 class Point;
 }
 
 namespace WebKit {
 struct WebFindOptions;
 struct WebMediaPlayerAction;
 struct WebPluginAction;
 }
 
+namespace content {
+
+class RenderViewHostDelegate;
+class SessionStorageNamespace;
+class SiteInstance;
+struct CustomContextMenuContext;
+
 // A RenderViewHost is responsible for creating and talking to a RenderView
 // object in a child process. It exposes a high level API to users, for things
 // like loading pages, adjusting the display and other browser functionality,
 // which it translates into IPC messages sent over the IPC channel with the
 // RenderView. It responds to all IPC messages sent by that RenderView and
 // cracks them, calling a delegate object back with higher level types where
 // possible.
 //
 // The intent of this interface is to provide a view-agnostic communication
 // conduit with a renderer. This is so we can build HTML views not only as
 // TabContents (see TabContents for an example) but also as views, etc.
-//
-// TODO(joi): Move to content namespace.
 class CONTENT_EXPORT RenderViewHost : virtual public RenderWidgetHost {
  public:
   // Returns the RenderViewHost given its ID and the ID of its render process.
   // Returns NULL if the IDs do not correspond to a live RenderViewHost.
   static RenderViewHost* FromID(int render_process_id, int render_view_id);
 
   // Downcasts from a RenderWidgetHost to a RenderViewHost.  Required
   // because RenderWidgetHost is a virtual base class.
   static RenderViewHost* From(RenderWidgetHost* rwh);
 
@@ skipping 74 matching lines @@
                                 const gfx::Size& max_size) = 0;
 
   // Turns off auto-resize and gives a new size that the view should be.
   virtual void DisableAutoResize(const gfx::Size& new_size) = 0;
 
   // Instructs the RenderView to send back updates to the preferred size.
   virtual void EnablePreferredSizeMode() = 0;
 
   // Executes custom context menu action that was provided from WebKit.
   virtual void ExecuteCustomContextMenuCommand(
-      int action, const content::CustomContextMenuContext& context) = 0;
+      int action, const CustomContextMenuContext& context) = 0;
 
   // Tells the renderer to perform the given action on the media player
   // located at the given point.
   virtual void ExecuteMediaPlayerActionAtLocation(
       const gfx::Point& location,
       const WebKit::WebMediaPlayerAction& action) = 0;
 
   // Runs some javascript within the context of a frame in the page.
   virtual void ExecuteJavascriptInWebFrame(const string16& frame_xpath,
                                            const string16& jscript) = 0;
@@ skipping 14 matching lines @@
 
   // Asks the renderer to exit fullscreen
   virtual void ExitFullscreen() = 0;
 
   // Finds text on a page.
   virtual void Find(int request_id, const string16& search_text,
                     const WebKit::WebFindOptions& options) = 0;
 
   // Notifies the renderer that the user has closed the FindInPage window
   // (and what action to take regarding the selection).
-  virtual void StopFinding(content::StopFindAction action) = 0;
+  virtual void StopFinding(StopFindAction action) = 0;
 
   // Causes the renderer to invoke the onbeforeunload event handler.  The
   // result will be returned via ViewMsg_ShouldClose. See also ClosePage and
   // SwapOut, which fire the PageUnload event.
   //
   // Set bool for_cross_site_transition when this close is just for the current
   // RenderView in the case of a cross-site transition. False means we're
   // closing the entire tab.
   virtual void FirePageBeforeUnload(bool for_cross_site_transition) = 0;
 
   // Notifies the Listener that one or more files have been chosen by the user
   // from a file chooser dialog for the form. |permissions| are flags from the
   // base::PlatformFileFlags enum which specify which file permissions should
   // be granted to the renderer.
   virtual void FilesSelectedInChooser(const std::vector<FilePath>& files,
                                       int permissions) = 0;
 
-  virtual content::RenderViewHostDelegate* GetDelegate() const = 0;
+  virtual RenderViewHostDelegate* GetDelegate() const = 0;
 
   // Returns a bitwise OR of bindings types that have been enabled for this
   // RenderView. See BindingsPolicy for details.
   virtual int GetEnabledBindings() const = 0;
 
-  virtual content::SessionStorageNamespace* GetSessionStorageNamespace() = 0;
+  virtual SessionStorageNamespace* GetSessionStorageNamespace() = 0;
 
-  virtual content::SiteInstance* GetSiteInstance() const = 0;
+  virtual SiteInstance* GetSiteInstance() const = 0;
 
   // Requests the renderer to evaluate an xpath to a frame and insert css
   // into that frame's document.
   virtual void InsertCSS(const string16& frame_xpath,
                          const std::string& css) = 0;
 
   // Returns true if the RenderView is active and has not crashed. Virtual
   // because it is overridden by TestRenderViewHost.
   virtual bool IsRenderViewLive() const = 0;
 
   // Let the renderer know that the menu has been closed.
   virtual void NotifyContextMenuClosed(
-      const content::CustomContextMenuContext& context) = 0;
+      const CustomContextMenuContext& context) = 0;
 
   // Notification that a move or resize renderer's containing window has
   // started.
   virtual void NotifyMoveOrResizeStarted() = 0;
 
   // Reloads the current focused frame.
   virtual void ReloadFrame() = 0;
 
   // Sets the alternate error page URL (link doctor) for the renderer process.
   virtual void SetAltErrorPageURL(const GURL& url) = 0;
 
   // Sets a property with the given name and value on the Web UI binding object.
   // Must call AllowWebUIBindings() on this renderer first.
   virtual void SetWebUIProperty(const std::string& name,
                                 const std::string& value) = 0;
 
   // Set the zoom level for the current main frame
   virtual void SetZoomLevel(double level) = 0;
 
   // Changes the zoom level for the current main frame.
-  virtual void Zoom(content::PageZoom zoom) = 0;
+  virtual void Zoom(PageZoom zoom) = 0;
 
   // Send the renderer process the current preferences supplied by the
   // RenderViewHostDelegate.
   virtual void SyncRendererPrefs() = 0;
 
   virtual void ToggleSpeechInput() = 0;
 
   // Passes a list of Webkit preferences to the renderer.
   virtual void UpdateWebkitPreferences(const WebPreferences& prefs) = 0;
 };
 
+}  // namespace content
 
 #endif  // CONTENT_PUBLIC_BROWSER_RENDER_VIEW_HOST_H_