Cleanup namespace usage in Source/web/Web[A-H]*.cpp

Source/web/WebAXObject.cpp

 /*
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 36 matching lines @@
 #include "core/rendering/style/RenderStyle.h"
 #include "platform/PlatformKeyboardEvent.h"
 #include "public/platform/WebPoint.h"
 #include "public/platform/WebRect.h"
 #include "public/platform/WebString.h"
 #include "public/platform/WebURL.h"
 #include "public/web/WebDocument.h"
 #include "public/web/WebNode.h"
 #include "wtf/text/StringBuilder.h"
 
-using namespace blink;
-
 namespace blink {
 
 void WebAXObject::reset()
 {
     m_private.reset();
 }
 
-void WebAXObject::assign(const blink::WebAXObject& other)
+void WebAXObject::assign(const WebAXObject& other)
 {
     m_private = other.m_private;
 }
 
 bool WebAXObject::equals(const WebAXObject& n) const
 {
     return m_private.get() == n.m_private.get();
 }
 
 // static
@@ skipping 628 matching lines @@
 {
     if (isDetached())
         return false;
 
     return m_private->press();
 }
 
 WebAXRole WebAXObject::role() const
 {
     if (isDetached())
-        return blink::WebAXRoleUnknown;
+        return WebAXRoleUnknown;
 
     return static_cast<WebAXRole>(m_private->roleValue());
 }
 
 unsigned WebAXObject::selectionEnd() const
 {
     if (isDetached())
         return 0;
 
     return m_private->selectedTextRange().start + m_private->selectedTextRange().length;
@@ skipping 228 matching lines @@
 }
 
 WebAXObject WebAXObject::cellForColumnAndRow(unsigned column, unsigned row) const
 {
     if (isDetached())
         return WebAXObject();
 
     if (!m_private->isAXTable())
         return WebAXObject();
 
-    blink::AXTableCell* cell = toAXTable(m_private.get())->cellForColumnAndRow(column, row);
-    return WebAXObject(static_cast<blink::AXObject*>(cell));
+    AXTableCell* cell = toAXTable(m_private.get())->cellForColumnAndRow(column, row);
+    return WebAXObject(static_cast<AXObject*>(cell));
 }
 
 WebAXObject WebAXObject::headerContainerObject() const
 {
     if (isDetached())
         return WebAXObject();
 
     if (!m_private->isAXTable())
         return WebAXObject();
 
@@ skipping 31 matching lines @@
 }
 
 unsigned WebAXObject::rowIndex() const
 {
     if (isDetached())
         return 0;
 
     if (!m_private->isTableRow())
         return 0;
 
-    return blink::toAXTableRow(m_private.get())->rowIndex();
+    return toAXTableRow(m_private.get())->rowIndex();
 }
 
 WebAXObject WebAXObject::rowHeader() const
 {
     if (isDetached())
         return WebAXObject();
 
     if (!m_private->isTableRow())
         return WebAXObject();
 
-    return WebAXObject(blink::toAXTableRow(m_private.get())->headerObject());
+    return WebAXObject(toAXTableRow(m_private.get())->headerObject());
 }
 
 unsigned WebAXObject::columnIndex() const
 {
     if (isDetached())
         return 0;
 
     if (m_private->roleValue() != ColumnRole)
         return 0;
 
-    return blink::toAXTableColumn(m_private.get())->columnIndex();
+    return toAXTableColumn(m_private.get())->columnIndex();
 }
 
 WebAXObject WebAXObject::columnHeader() const
 {
     if (isDetached())
         return WebAXObject();
 
     if (m_private->roleValue() != ColumnRole)
         return WebAXObject();
 
-    return WebAXObject(blink::toAXTableColumn(m_private.get())->headerObject());
+    return WebAXObject(toAXTableColumn(m_private.get())->headerObject());
 }
 
 unsigned WebAXObject::cellColumnIndex() const
 {
     if (isDetached())
         return 0;
 
     if (!m_private->isTableCell())
         return 0;
 
     pair<unsigned, unsigned> columnRange;
-    blink::toAXTableCell(m_private.get())->columnIndexRange(columnRange);
+    toAXTableCell(m_private.get())->columnIndexRange(columnRange);
     return columnRange.first;
 }
 
 unsigned WebAXObject::cellColumnSpan() const
 {
     if (isDetached())
         return 0;
 
     if (!m_private->isTableCell())
         return 0;
 
     pair<unsigned, unsigned> columnRange;
-    blink::toAXTableCell(m_private.get())->columnIndexRange(columnRange);
+    toAXTableCell(m_private.get())->columnIndexRange(columnRange);
     return columnRange.second;
 }
 
 unsigned WebAXObject::cellRowIndex() const
 {
     if (isDetached())
         return 0;
 
     if (!m_private->isTableCell())
         return 0;
 
     pair<unsigned, unsigned> rowRange;
-    blink::toAXTableCell(m_private.get())->rowIndexRange(rowRange);
+    toAXTableCell(m_private.get())->rowIndexRange(rowRange);
     return rowRange.first;
 }
 
 unsigned WebAXObject::cellRowSpan() const
 {
     if (isDetached())
         return 0;
 
     if (!m_private->isTableCell())
         return 0;
 
     pair<unsigned, unsigned> rowRange;
-    blink::toAXTableCell(m_private.get())->rowIndexRange(rowRange);
+    toAXTableCell(m_private.get())->rowIndexRange(rowRange);
     return rowRange.second;
 }
 
 WebAXTextDirection WebAXObject::textDirection() const
 {
     if (isDetached())
         return WebAXTextDirectionLR;
 
     return static_cast<WebAXTextDirection>(m_private->textDirection());
 }
@@ skipping 42 matching lines @@
     if (!isDetached())
         m_private->scrollToMakeVisibleWithSubFocus(subfocus);
 }
 
 void WebAXObject::scrollToGlobalPoint(const WebPoint& point) const
 {
     if (!isDetached())
         m_private->scrollToGlobalPoint(point);
 }
 
-WebAXObject::WebAXObject(const WTF::PassRefPtr<blink::AXObject>& object)
+WebAXObject::WebAXObject(const WTF::PassRefPtr<AXObject>& object)
     : m_private(object)
 {
 }
 
-WebAXObject& WebAXObject::operator=(const WTF::PassRefPtr<blink::AXObject>& object)
+WebAXObject& WebAXObject::operator=(const WTF::PassRefPtr<AXObject>& object)
 {
     m_private = object;
     return *this;
 }
 
-WebAXObject::operator WTF::PassRefPtr<blink::AXObject>() const
+WebAXObject::operator WTF::PassRefPtr<AXObject>() const
 {
     return m_private.get();
 }
 
 } // namespace blink