Cleanup namespace usage in platform/graphics/[filters/* to skia/*] and platform/graphics/[B-D]*

Source/platform/graphics/filters/FEConvolveMatrix.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007 Nikolas Zimmermann <zimmermann@kde.org>
  * Copyright (C) 2004, 2005 Rob Buis <buis@kde.org>
  * Copyright (C) 2005 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2009 Dirk Schulze <krit@webkit.org>
  * Copyright (C) 2010 Zoltan Herczeg <zherczeg@webkit.org>
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ skipping 442 matching lines @@
     paintingData.bias = m_bias * 255;
 
     // Drawing fully covered pixels
     int clipRight = paintSize.width() - m_kernelSize.width();
     int clipBottom = paintSize.height() - m_kernelSize.height();
 
     if (clipRight >= 0 && clipBottom >= 0) {
 
         int optimalThreadNumber = (absolutePaintRect().width() * absolutePaintRect().height()) / s_minimalRectDimension;
         if (optimalThreadNumber > 1) {
-            ParallelJobs<InteriorPixelParameters> parallelJobs(&blink::FEConvolveMatrix::setInteriorPixelsWorker, optimalThreadNumber);
+            ParallelJobs<InteriorPixelParameters> parallelJobs(&FEConvolveMatrix::setInteriorPixelsWorker, optimalThreadNumber);
             const int numOfThreads = parallelJobs.numberOfJobs();
 
             // Split the job into "heightPerThread" jobs but there a few jobs that need to be slightly larger since
             // heightPerThread * jobs < total size. These extras are handled by the remainder "jobsWithExtra".
             const int heightPerThread = clipBottom / numOfThreads;
             const int jobsWithExtra = clipBottom % numOfThreads;
 
             int startY = 0;
             for (int job = 0; job < numOfThreads; ++job) {
                 InteriorPixelParameters& param = parallelJobs.parameter(job);
@@ skipping 21 matching lines @@
         if (m_targetOffset.x() > 0)
             setOuterPixels(paintingData, 0, m_targetOffset.y(), m_targetOffset.x(), clipBottom);
         if (clipRight < paintSize.width())
             setOuterPixels(paintingData, clipRight, m_targetOffset.y(), paintSize.width(), clipBottom);
     } else {
         // Rare situation, not optimizied for speed
         setOuterPixels(paintingData, 0, 0, paintSize.width(), paintSize.height());
     }
 }
 
-SkMatrixConvolutionImageFilter::TileMode toSkiaTileMode(blink::EdgeModeType edgeMode)
+SkMatrixConvolutionImageFilter::TileMode toSkiaTileMode(EdgeModeType edgeMode)
 {
     switch (edgeMode) {
-    case blink::EDGEMODE_DUPLICATE:
+    case EDGEMODE_DUPLICATE:
         return SkMatrixConvolutionImageFilter::kClamp_TileMode;
-    case blink::EDGEMODE_WRAP:
+    case EDGEMODE_WRAP:
         return SkMatrixConvolutionImageFilter::kRepeat_TileMode;
-    case blink::EDGEMODE_NONE:
+    case EDGEMODE_NONE:
         return SkMatrixConvolutionImageFilter::kClampToBlack_TileMode;
     default:
         return SkMatrixConvolutionImageFilter::kClamp_TileMode;
     }
 }
 
-}; // unnamed namespace
-
-namespace blink {
-
 PassRefPtr<SkImageFilter> FEConvolveMatrix::createImageFilter(SkiaImageFilterBuilder* builder)
 {
     RefPtr<SkImageFilter> input(builder->build(inputEffect(0), operatingColorSpace()));
 
     SkISize kernelSize(SkISize::Make(m_kernelSize.width(), m_kernelSize.height()));
     int numElements = kernelSize.width() * kernelSize.height();
     SkScalar gain = SkFloatToScalar(1.0f / m_divisor);
     SkScalar bias = SkFloatToScalar(m_bias * 255);
     SkIPoint target = SkIPoint::Make(m_targetOffset.x(), m_targetOffset.y());
     SkMatrixConvolutionImageFilter::TileMode tileMode = toSkiaTileMode(m_edgeMode);
@@ skipping 35 matching lines @@
        << "bias=\"" << m_bias << "\" "
        << "target=\"" << m_targetOffset << "\" "
        << "edgeMode=\"" << m_edgeMode << "\" "
        << "kernelUnitLength=\"" << m_kernelUnitLength << "\" "
        << "preserveAlpha=\"" << m_preserveAlpha << "\"]\n";
     inputEffect(0)->externalRepresentation(ts, indent + 1);
     return ts;
 }
 
 }; // namespace blink