Move a bunch more code into the content namespace.

content/browser/web_contents/web_contents_view_aura.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/browser/web_contents/web_contents_view_aura.h"
 
 #include "base/utf_string_conversions.h"
 #include "content/browser/renderer_host/dip_util.h"
 #include "content/browser/renderer_host/render_view_host_factory.h"
 #include "content/browser/web_contents/interstitial_page_impl.h"
@@ skipping 26 matching lines @@
 
 namespace content {
 WebContentsView* CreateWebContentsView(
     WebContentsImpl* web_contents,
     WebContentsViewDelegate* delegate,
     RenderViewHostDelegateView** render_view_host_delegate_view) {
   WebContentsViewAura* rv = new WebContentsViewAura(web_contents, delegate);
   *render_view_host_delegate_view = rv;
   return rv;
 }
-}
 
 namespace {
 
 // Listens to all mouse drag events during a drag and drop and sends them to
 // the renderer.
 class WebDragSourceAura : public MessageLoopForUI::Observer,
-                          public content::NotificationObserver {
+                          public NotificationObserver {
  public:
   WebDragSourceAura(aura::Window* window, WebContentsImpl* contents)
       : window_(window),
         contents_(contents) {
     MessageLoopForUI::current()->AddObserver(this);
-    registrar_.Add(this, content::NOTIFICATION_WEB_CONTENTS_DISCONNECTED,
-                   content::Source<content::WebContents>(contents));
+    registrar_.Add(this, NOTIFICATION_WEB_CONTENTS_DISCONNECTED,
+                   Source<WebContents>(contents));
   }
 
   virtual ~WebDragSourceAura() {
     MessageLoopForUI::current()->RemoveObserver(this);
   }
 
   // MessageLoop::Observer implementation:
   virtual base::EventStatus WillProcessEvent(
       const base::NativeEvent& event) OVERRIDE {
     return base::EVENT_CONTINUE;
   }
   virtual void DidProcessEvent(const base::NativeEvent& event) OVERRIDE {
     if (!contents_)
       return;
     ui::EventType type = ui::EventTypeFromNative(event);
-    content::RenderViewHost* rvh = NULL;
+    RenderViewHost* rvh = NULL;
     switch (type) {
       case ui::ET_MOUSE_DRAGGED:
         rvh = contents_->GetRenderViewHost();
         if (rvh) {
           gfx::Point screen_loc_in_pixel = ui::EventLocationFromNative(event);
-          gfx::Point screen_loc = content::ConvertPointToDIP(rvh->GetView(),
+          gfx::Point screen_loc = ConvertPointToDIP(rvh->GetView(),
               screen_loc_in_pixel);
           gfx::Point client_loc = screen_loc;
           aura::Window* window = rvh->GetView()->GetNativeView();
           aura::Window::ConvertPointToTarget(window->GetRootWindow(),
               window, &client_loc);
           rvh->DragSourceMovedTo(client_loc.x(), client_loc.y(),
               screen_loc.x(), screen_loc.y());
         }
         break;
       default:
         break;
     }
   }
 
   virtual void Observe(int type,
-      const content::NotificationSource& source,
-      const content::NotificationDetails& details) OVERRIDE {
-    if (type != content::NOTIFICATION_WEB_CONTENTS_DISCONNECTED)
+      const NotificationSource& source,
+      const NotificationDetails& details) OVERRIDE {
+    if (type != NOTIFICATION_WEB_CONTENTS_DISCONNECTED)
       return;
 
     // Cancel the drag if it is still in progress.
     aura::client::DragDropClient* dnd_client =
         aura::client::GetDragDropClient(window_->GetRootWindow());
     if (dnd_client && dnd_client->IsDragDropInProgress())
       dnd_client->DragCancel();
 
     window_ = NULL;
     contents_ = NULL;
   }
 
   aura::Window* window() const { return window_; }
 
  private:
   aura::Window* window_;
   WebContentsImpl* contents_;
-  content::NotificationRegistrar registrar_;
+  NotificationRegistrar registrar_;
 
   DISALLOW_COPY_AND_ASSIGN(WebDragSourceAura);
 };
 
 // Utility to fill a ui::OSExchangeDataProviderAura object from WebDropData.
 void PrepareDragData(const WebDropData& drop_data,
                      ui::OSExchangeDataProviderAura* provider) {
   if (!drop_data.text.string().empty())
     provider->SetString(drop_data.text.string());
   if (drop_data.url.is_valid())
@@ skipping 100 matching lines @@
 }
 
 }  // namespace
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // WebContentsViewAura, public:
 
 WebContentsViewAura::WebContentsViewAura(
     WebContentsImpl* web_contents,
-    content::WebContentsViewDelegate* delegate)
+    WebContentsViewDelegate* delegate)
     : web_contents_(web_contents),
       view_(NULL),
       delegate_(delegate),
       current_drag_op_(WebKit::WebDragOperationNone),
       drag_dest_delegate_(NULL),
       current_rvh_for_drag_(NULL) {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // WebContentsViewAura, private:
 
 WebContentsViewAura::~WebContentsViewAura() {
   // Window needs a valid delegate during its destructor, so we explicitly
   // delete it here.
   window_.reset();
 }
 
 void WebContentsViewAura::SizeChangedCommon(const gfx::Size& size) {
   if (web_contents_->GetInterstitialPage())
     web_contents_->GetInterstitialPage()->SetSize(size);
-  content::RenderWidgetHostView* rwhv =
+  RenderWidgetHostView* rwhv =
       web_contents_->GetRenderWidgetHostView();
   if (rwhv)
     rwhv->SetSize(size);
 }
 
 void WebContentsViewAura::EndDrag(WebKit::WebDragOperationsMask ops) {
   aura::RootWindow* root_window = GetNativeView()->GetRootWindow();
   gfx::Point screen_loc =
       gfx::Screen::GetScreenFor(GetNativeView())->GetCursorScreenPoint();
   gfx::Point client_loc = screen_loc;
-  content::RenderViewHost* rvh = web_contents_->GetRenderViewHost();
+  RenderViewHost* rvh = web_contents_->GetRenderViewHost();
   aura::Window* window = rvh->GetView()->GetNativeView();
   aura::Window::ConvertPointToTarget(root_window, window, &client_loc);
   rvh->DragSourceEndedAt(client_loc.x(), client_loc.y(), screen_loc.x(),
       screen_loc.y(), ops);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // WebContentsViewAura, WebContentsView implementation:
 
 void WebContentsViewAura::CreateView(const gfx::Size& initial_size) {
@@ skipping 10 matching lines @@
   window_->layer()->SetMasksToBounds(true);
   window_->SetName("WebContentsViewAura");
 
   // delegate_->GetDragDestDelegate() creates a new delegate on every call.
   // Hence, we save a reference to it locally. Similar model is used on other
   // platforms as well.
   if (delegate_.get())
     drag_dest_delegate_ = delegate_->GetDragDestDelegate();
 }
 
-content::RenderWidgetHostView* WebContentsViewAura::CreateViewForWidget(
-    content::RenderWidgetHost* render_widget_host) {
+RenderWidgetHostView* WebContentsViewAura::CreateViewForWidget(
+    RenderWidgetHost* render_widget_host) {
   if (render_widget_host->GetView()) {
     // During testing, the view will already be set up in most cases to the
     // test view, so we don't want to clobber it with a real one. To verify that
     // this actually is happening (and somebody isn't accidentally creating the
     // view twice), we check for the RVH Factory, which will be set when we're
     // making special ones (which go along with the special views).
     DCHECK(RenderViewHostFactory::has_factory());
     return render_widget_host->GetView();
   }
 
-  view_ = content::RenderWidgetHostView::CreateViewForWidget(
+  view_ = RenderWidgetHostView::CreateViewForWidget(
       render_widget_host);
   view_->InitAsChild(NULL);
   GetNativeView()->AddChild(view_->GetNativeView());
   view_->Show();
 
   // We listen to drag drop events in the newly created view's window.
   aura::client::SetDragDropDelegate(view_->GetNativeView(), this);
   return view_;
 }
 
@@ skipping 31 matching lines @@
   if (bounds.size() != size) {
     bounds.set_size(size);
     window_->SetBounds(bounds);
   } else {
     // Our size matches what we want but the renderers size may not match.
     // Pretend we were resized so that the renderers size is updated too.
     SizeChangedCommon(size);
   }
 }
 
-void WebContentsViewAura::RenderViewCreated(content::RenderViewHost* host) {
+void WebContentsViewAura::RenderViewCreated(RenderViewHost* host) {
 }
 
 void WebContentsViewAura::Focus() {
   if (web_contents_->GetInterstitialPage()) {
     web_contents_->GetInterstitialPage()->Focus();
     return;
   }
 
   if (delegate_.get() && delegate_->Focus())
     return;
 
-  content::RenderWidgetHostView* rwhv =
-      web_contents_->GetRenderWidgetHostView();
+  RenderWidgetHostView* rwhv = web_contents_->GetRenderWidgetHostView();
   if (rwhv)
     rwhv->Focus();
 }
 
 void WebContentsViewAura::SetInitialFocus() {
   if (web_contents_->FocusLocationBarByDefault())
     web_contents_->SetFocusToLocationBar(false);
   else
     Focus();
 }
@@ skipping 20 matching lines @@
 }
 
 gfx::Rect WebContentsViewAura::GetViewBounds() const {
   return window_->GetBoundsInRootWindow();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // WebContentsViewAura, RenderViewHostDelegateView implementation:
 
 void WebContentsViewAura::ShowContextMenu(
-    const content::ContextMenuParams& params,
-    content::ContextMenuSourceType type) {
+    const ContextMenuParams& params,
+    ContextMenuSourceType type) {
   if (delegate_.get())
     delegate_->ShowContextMenu(params, type);
 }
 
 void WebContentsViewAura::ShowPopupMenu(const gfx::Rect& bounds,
                                         int item_height,
                                         double item_font_size,
                                         int selected_item,
                                         const std::vector<WebMenuItem>& items,
                                         bool right_aligned,
@@ skipping 249 matching lines @@
     OnDragEntered(event);
 
   web_contents_->GetRenderViewHost()->DragTargetDrop(
       event.location(),
       gfx::Screen::GetScreenFor(GetNativeView())->GetCursorScreenPoint(),
       ConvertAuraEventFlagsToWebInputEventModifiers(event.flags()));
   if (drag_dest_delegate_)
     drag_dest_delegate_->OnDrop();
   return current_drag_op_;
 }
+
+}  // namespace content