Move more files into the content namespace.

content/browser/renderer_host/render_widget_host_view_win.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/renderer_host/render_widget_host_view_win.h"
 
 #include <algorithm>
 #include <map>
 #include <peninputpanel_i.c>
 #include <stack>
@@ skipping 53 matching lines @@
 #include "webkit/glue/webcursor.h"
 #include "webkit/plugins/npapi/plugin_constants_win.h"
 #include "webkit/plugins/npapi/webplugin.h"
 #include "webkit/plugins/npapi/webplugin_delegate_impl.h"
 
 // From MSDN.
 #define MOUSEEVENTF_FROMTOUCH 0xFF515700
 
 using base::TimeDelta;
 using base::TimeTicks;
-using content::BrowserThread;
-using content::NativeWebKeyboardEvent;
-using content::RenderWidgetHost;
-using content::RenderWidgetHostImpl;
-using content::RenderWidgetHostView;
 using ui::ViewProp;
 using WebKit::WebInputEvent;
 using WebKit::WebInputEventFactory;
 using WebKit::WebMouseEvent;
 using WebKit::WebTextDirection;
 using webkit::npapi::WebPluginGeometry;
 
-const wchar_t kRenderWidgetHostHWNDClass[] = L"Chrome_RenderWidgetHostHWND";
+namespace content {
+namespace {
 
-namespace {
 // Tooltips will wrap after this width. Yes, wrap. Imagine that!
 const int kTooltipMaxWidthPixels = 300;
 
 // Maximum number of characters we allow in a tooltip.
 const int kMaxTooltipLength = 1024;
 
 // A custom MSAA object id used to determine if a screen reader is actively
 // listening for MSAA events.
 const int kIdCustom = 1;
 
@@ skipping 107 matching lines @@
 
   gpu_process_host->Send(message.release());
 }
 
 void PostTaskOnIOThread(const tracked_objects::Location& from_here,
                         base::Closure task) {
   BrowserThread::PostTask(BrowserThread::IO, from_here, task);
 }
 
 bool DecodeZoomGesture(HWND hwnd, const GESTUREINFO& gi,
-                       content::PageZoom* zoom,
-                       POINT* zoom_center) {
+                       PageZoom* zoom, POINT* zoom_center) {
   static long start = 0;
   static POINT zoom_first;
 
   if (gi.dwFlags == GF_BEGIN) {
     start = gi.ullArguments;
     zoom_first.x = gi.ptsLocation.x;
     zoom_first.y = gi.ptsLocation.y;
     ScreenToClient(hwnd, &zoom_first);
     return false;
   }
 
   if (gi.dwFlags == GF_END)
     return false;
 
   POINT zoom_second = {0};
   zoom_second.x = gi.ptsLocation.x;
   zoom_second.y = gi.ptsLocation.y;
   ScreenToClient(hwnd, &zoom_second);
 
   if (zoom_first.x == zoom_second.x && zoom_first.y == zoom_second.y)
     return false;
 
   zoom_center->x = (zoom_first.x + zoom_second.x) / 2;
   zoom_center->y = (zoom_first.y + zoom_second.y) / 2;
 
   double zoom_factor =
       static_cast<double>(gi.ullArguments)/static_cast<double>(start);
 
-  *zoom = zoom_factor >= 1 ? content::PAGE_ZOOM_IN :
-              content::PAGE_ZOOM_OUT;
+  *zoom = zoom_factor >= 1 ? PAGE_ZOOM_IN : PAGE_ZOOM_OUT;
 
   start = gi.ullArguments;
   zoom_first = zoom_second;
   return true;
 }
 
 bool DecodeScrollGesture(const GESTUREINFO& gi,
                          POINT* start,
                          POINT* delta){
   // Windows gestures are streams of messages with begin/end messages that
@@ skipping 253 matching lines @@
   }
 
  private:
   size_t index_;
 
   DISALLOW_COPY_AND_ASSIGN(LocalTouchEvent);
 };
 
 }  // namespace
 
+const wchar_t kRenderWidgetHostHWNDClass[] = L"Chrome_RenderWidgetHostHWND";
+
 // Wrapper for maintaining touchstate associated with a WebTouchEvent.
 class WebTouchState {
  public:
   explicit WebTouchState(const RenderWidgetHostViewWin* window);
 
   // Updates the current touchpoint state with the supplied touches.
   // Touches will be consumed only if they are of the same type (e.g. down,
   // up, move). Returns the number of consumed touches.
   size_t UpdateTouchPoints(TOUCHINPUT* points, size_t count);
 
@@ skipping 80 matching lines @@
       ALLOW_THIS_IN_INITIALIZER_LIST(
           touch_state_(new WebTouchState(this))),
       pointer_down_context_(false),
       focus_on_editable_field_(false),
       received_focus_change_after_pointer_down_(false),
       touch_events_enabled_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           gesture_recognizer_(ui::GestureRecognizer::Create(this))) {
   render_widget_host_->SetView(this);
   registrar_.Add(this,
-                 content::NOTIFICATION_RENDERER_PROCESS_TERMINATED,
-                 content::NotificationService::AllBrowserContextsAndSources());
+                 NOTIFICATION_RENDERER_PROCESS_TERMINATED,
+                 NotificationService::AllBrowserContextsAndSources());
   registrar_.Add(this,
-                 content::NOTIFICATION_FOCUS_CHANGED_IN_PAGE,
-                 content::NotificationService::AllBrowserContextsAndSources());
+                 NOTIFICATION_FOCUS_CHANGED_IN_PAGE,
+                 NotificationService::AllBrowserContextsAndSources());
 }
 
 RenderWidgetHostViewWin::~RenderWidgetHostViewWin() {
   UnlockMouse();
   ResetTooltip();
 }
 
 void RenderWidgetHostViewWin::CreateWnd(HWND parent) {
   // ATL function to create the window.
   Create(parent);
@@ skipping 108 matching lines @@
 gfx::NativeViewAccessible
 RenderWidgetHostViewWin::GetNativeViewAccessible() {
   if (render_widget_host_ &&
       !BrowserAccessibilityState::GetInstance()->IsAccessibleBrowser()) {
     // Attempt to detect screen readers by sending an event with our custom id.
     NotifyWinEvent(EVENT_SYSTEM_ALERT, m_hWnd, kIdCustom, CHILDID_SELF);
   }
 
   if (!GetBrowserAccessibilityManager()) {
     // Return busy document tree while renderer accessibility tree loads.
-    content::AccessibilityNodeData::State busy_state =
-        static_cast<content::AccessibilityNodeData::State>(
-            1 << content::AccessibilityNodeData::STATE_BUSY);
+    AccessibilityNodeData::State busy_state =
+        static_cast<AccessibilityNodeData::State>(
+            1 << AccessibilityNodeData::STATE_BUSY);
     SetBrowserAccessibilityManager(
         BrowserAccessibilityManager::CreateEmptyDocument(
             m_hWnd, busy_state, this));
   }
 
   return GetBrowserAccessibilityManager()->GetRoot()->
       ToBrowserAccessibilityWin();
 }
 
 void RenderWidgetHostViewWin::MovePluginWindows(
@@ skipping 215 matching lines @@
 
 void RenderWidgetHostViewWin::UpdateCursor(const WebCursor& cursor) {
   current_cursor_ = cursor;
   UpdateCursorIfOverSelf();
 }
 
 void RenderWidgetHostViewWin::UpdateCursorIfOverSelf() {
   static HCURSOR kCursorArrow = LoadCursor(NULL, IDC_ARROW);
   static HCURSOR kCursorAppStarting = LoadCursor(NULL, IDC_APPSTARTING);
   static HINSTANCE module_handle = GetModuleHandle(
-      content::GetContentClient()->browser()->GetResourceDllName());
+      GetContentClient()->browser()->GetResourceDllName());
 
   // If the mouse is over our HWND, then update the cursor state immediately.
   CPoint pt;
   GetCursorPos(&pt);
   if (WindowFromPoint(pt) == m_hWnd) {
     // We cannot pass in NULL as the module handle as this would only work for
     // standard win32 cursors. We can also receive cursor types which are
     // defined as webkit resources. We need to specify the module handle of
     // chrome.dll while loading these cursors.
     HCURSOR display_cursor = current_cursor_.GetCursor(module_handle);
@@ skipping 194 matching lines @@
   if (!output->initialize(size.width(), size.height(), true))
     return;
 
   const bool result = accelerated_surface_->CopyTo(
       size, output->getTopDevice()->accessBitmap(true).getPixels());
   scoped_callback_runner.Release();
   callback.Run(result);
 }
 
 void RenderWidgetHostViewWin::SetBackground(const SkBitmap& background) {
-  content::RenderWidgetHostViewBase::SetBackground(background);
+  RenderWidgetHostViewBase::SetBackground(background);
   render_widget_host_->SetBackground(background);
 }
 
 void RenderWidgetHostViewWin::ProcessTouchAck(
     WebKit::WebInputEvent::Type type, bool processed) {
 
   DCHECK(render_widget_host_->has_touch_handler() &&
       touch_events_enabled_);
 
   int touch_count = touch_state_->GetNextTouchCount();
@@ skipping 1157 matching lines @@
 
   GESTUREINFO gi = {sizeof(GESTUREINFO)};
   HGESTUREINFO gi_handle = reinterpret_cast<HGESTUREINFO>(lparam);
   if (!::GetGestureInfo(gi_handle, &gi)) {
     DWORD error = GetLastError();
     NOTREACHED() << "Unable to get gesture info. Error : " << error;
     return 0;
   }
 
   if (gi.dwID == GID_ZOOM) {
-    content::PageZoom zoom = content::PAGE_ZOOM_RESET;
+    PageZoom zoom = PAGE_ZOOM_RESET;
     POINT zoom_center = {0};
     if (DecodeZoomGesture(m_hWnd, gi, &zoom, &zoom_center)) {
       handled = TRUE;
       Send(new ViewMsg_ZoomFactor(render_widget_host_->GetRoutingID(),
                                   zoom, zoom_center.x, zoom_center.y));
     }
   } else if (gi.dwID == GID_PAN) {
     // Right now we only decode scroll gestures and we forward to the page
     // as scroll events.
     POINT start;
     POINT delta;
     if (DecodeScrollGesture(gi, &start, &delta)) {
       handled = TRUE;
       render_widget_host_->ForwardWheelEvent(
           MakeFakeScrollWheelEvent(m_hWnd, start, delta));
     }
   }
   ::CloseGestureInfoHandle(gi_handle);
   return 0;
 }
 
 void RenderWidgetHostViewWin::OnAccessibilityNotifications(
     const std::vector<AccessibilityHostMsg_NotificationParams>& params) {
   if (!GetBrowserAccessibilityManager()) {
     SetBrowserAccessibilityManager(
         BrowserAccessibilityManager::CreateEmptyDocument(
             m_hWnd,
-            static_cast<content::AccessibilityNodeData::State>(0),
+            static_cast<AccessibilityNodeData::State>(0),
             this));
   }
   GetBrowserAccessibilityManager()->OnAccessibilityNotifications(params);
 }
 
 bool RenderWidgetHostViewWin::LockMouse() {
   if (mouse_locked_)
     return true;
 
   mouse_locked_ = true;
@@ skipping 34 matching lines @@
   ::SetCursorPos(last_mouse_position_.unlocked_global.x(),
                  last_mouse_position_.unlocked_global.y());
   ::ShowCursor(TRUE);
 
   if (render_widget_host_)
     render_widget_host_->LostMouseLock();
 }
 
 void RenderWidgetHostViewWin::Observe(
     int type,
-    const content::NotificationSource& source,
-    const content::NotificationDetails& details) {
-  DCHECK(type == content::NOTIFICATION_RENDERER_PROCESS_TERMINATED ||
-         type == content::NOTIFICATION_FOCUS_CHANGED_IN_PAGE);
+    const NotificationSource& source,
+    const NotificationDetails& details) {
+  DCHECK(type == NOTIFICATION_RENDERER_PROCESS_TERMINATED ||
+         type == NOTIFICATION_FOCUS_CHANGED_IN_PAGE);
 
-  if (type == content::NOTIFICATION_FOCUS_CHANGED_IN_PAGE) {
+  if (type == NOTIFICATION_FOCUS_CHANGED_IN_PAGE) {
     if (pointer_down_context_)
       received_focus_change_after_pointer_down_ = true;
-    focus_on_editable_field_ = *content::Details<bool>(details).ptr();
+    focus_on_editable_field_ = *Details<bool>(details).ptr();
     if (virtual_keyboard_)
       DisplayOnScreenKeyboardIfNeeded();
   } else {
     // Get the RenderProcessHost that posted this notification, and exit
     // if it's not the one associated with this host view.
-    content::RenderProcessHost* render_process_host =
-        content::Source<content::RenderProcessHost>(source).ptr();
+    RenderProcessHost* render_process_host =
+        Source<RenderProcessHost>(source).ptr();
     DCHECK(render_process_host);
     if (!render_widget_host_ ||
         render_process_host != render_widget_host_->GetProcess())
       return;
 
     // If it was our RenderProcessHost that posted the notification,
     // clear the BrowserAccessibilityManager, because the renderer is
     // dead and any accessibility information we have is now stale.
     SetBrowserAccessibilityManager(NULL);
   }
@@ skipping 656 matching lines @@
 void RenderWidgetHostViewWin::ResetPointerDownContext() {
   // If the default focus on the page is on an edit field and we did not
   // receive a focus change in the context of a pointer down message, it means
   // that the pointer down message occurred on the edit field and we should
   // display the on screen keyboard
   if (!received_focus_change_after_pointer_down_ && virtual_keyboard_)
     DisplayOnScreenKeyboardIfNeeded();
   received_focus_change_after_pointer_down_ = false;
   pointer_down_context_ = false;
 }
+
+}  // namespace content