Use std::string instead of WTF::String / TextStream

cc/CCRendererGL.cpp

 // Copyright 2010 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 "config.h"
 
 #if USE(ACCELERATED_COMPOSITING)
 #include "CCRendererGL.h"
 
@@ skipping 11 matching lines @@
 #include "FloatQuad.h"
 #include "GeometryBinding.h"
 #include "GrTexture.h"
 #include "NotImplemented.h"
 #include "PlatformColor.h"
 #include "SkBitmap.h"
 #include "SkColor.h"
 #include "ThrottledTextureUploader.h"
 #include "TraceEvent.h"
 #include "UnthrottledTextureUploader.h"
+#ifdef LOG
+#undef LOG
+#endif
+#include "base/string_split.h"
 #include <public/WebGraphicsContext3D.h>
 #include <public/WebSharedGraphicsContext3D.h>
 #include <public/WebVideoFrame.h>
+#include <set>
+#include <string>
+#include <vector>
 #include <wtf/CurrentTime.h>
 #include <wtf/MainThread.h>
-#include <wtf/text/StringHash.h>
 
 using namespace std;
 using WebKit::WebGraphicsContext3D;
 using WebKit::WebGraphicsMemoryAllocation;
 using WebKit::WebSharedGraphicsContext3D;
 using WebKit::WebTransformationMatrix;
 
 namespace WebCore {
 
 namespace {
@@ skipping 35 matching lines @@
 }
 
 bool CCRendererGL::initialize()
 {
     if (!m_context->makeContextCurrent())
         return false;
 
     m_context->setContextLostCallback(this);
     m_context->pushGroupMarkerEXT("CompositorContext");
 
-    WebKit::WebString extensionsWebString = m_context->getString(GraphicsContext3D::EXTENSIONS);
-    String extensionsString(extensionsWebString.data(), extensionsWebString.length());
-    Vector<String> extensionsList;
-    extensionsString.split(' ', extensionsList);
-    HashSet<String> extensions;
-    for (size_t i = 0; i < extensionsList.size(); ++i)
-        extensions.add(extensionsList[i]);
+    std::string extensionsString = UTF16ToASCII(m_context->getString(GraphicsContext3D::EXTENSIONS));
+    std::vector<std::string> extensionsList;
+    base::SplitString(extensionsString, ' ', &extensionsList);
+    std::set<string> extensions(extensionsList.begin(), extensionsList.end());
 
-    if (settings().acceleratePainting && extensions.contains("GL_EXT_texture_format_BGRA8888")
-                                      && extensions.contains("GL_EXT_read_format_bgra"))
+    if (settings().acceleratePainting && extensions.count("GL_EXT_texture_format_BGRA8888")
+                                      && extensions.count("GL_EXT_read_format_bgra"))
         m_capabilities.usingAcceleratedPainting = true;
     else
         m_capabilities.usingAcceleratedPainting = false;
 
 
-    m_capabilities.contextHasCachedFrontBuffer = extensions.contains("GL_CHROMIUM_front_buffer_cached");
+    m_capabilities.contextHasCachedFrontBuffer = extensions.count("GL_CHROMIUM_front_buffer_cached");
 
-    m_capabilities.usingPartialSwap = CCSettings::partialSwapEnabled() && extensions.contains("GL_CHROMIUM_post_sub_buffer");
+    m_capabilities.usingPartialSwap = CCSettings::partialSwapEnabled() && extensions.count("GL_CHROMIUM_post_sub_buffer");
 
     // Use the swapBuffers callback only with the threaded proxy.
     if (CCProxy::hasImplThread())
-        m_capabilities.usingSwapCompleteCallback = extensions.contains("GL_CHROMIUM_swapbuffers_complete_callback");
+        m_capabilities.usingSwapCompleteCallback = extensions.count("GL_CHROMIUM_swapbuffers_complete_callback");
     if (m_capabilities.usingSwapCompleteCallback)
         m_context->setSwapBuffersCompleteCallbackCHROMIUM(this);
 
-    m_capabilities.usingSetVisibility = extensions.contains("GL_CHROMIUM_set_visibility");
+    m_capabilities.usingSetVisibility = extensions.count("GL_CHROMIUM_set_visibility");
 
-    if (extensions.contains("GL_CHROMIUM_iosurface"))
-        ASSERT(extensions.contains("GL_ARB_texture_rectangle"));
+    if (extensions.count("GL_CHROMIUM_iosurface"))
+        ASSERT(extensions.count("GL_ARB_texture_rectangle"));
 
-    m_capabilities.usingGpuMemoryManager = extensions.contains("GL_CHROMIUM_gpu_memory_manager");
+    m_capabilities.usingGpuMemoryManager = extensions.count("GL_CHROMIUM_gpu_memory_manager");
     if (m_capabilities.usingGpuMemoryManager)
         m_context->setMemoryAllocationChangedCallbackCHROMIUM(this);
 
-    m_capabilities.usingDiscardFramebuffer = extensions.contains("GL_CHROMIUM_discard_framebuffer");
+    m_capabilities.usingDiscardFramebuffer = extensions.count("GL_CHROMIUM_discard_framebuffer");
 
-    m_capabilities.usingEglImage = extensions.contains("GL_OES_EGL_image_external");
+    m_capabilities.usingEglImage = extensions.count("GL_OES_EGL_image_external");
 
     GLC(m_context, m_context->getIntegerv(GraphicsContext3D::MAX_TEXTURE_SIZE, &m_capabilities.maxTextureSize));
-    m_capabilities.bestTextureFormat = PlatformColor::bestTextureFormat(m_context, extensions.contains("GL_EXT_texture_format_BGRA8888"));
+    m_capabilities.bestTextureFormat = PlatformColor::bestTextureFormat(m_context, extensions.count("GL_EXT_texture_format_BGRA8888"));
 
-    m_isUsingBindUniform = extensions.contains("GL_CHROMIUM_bind_uniform_location");
+    m_isUsingBindUniform = extensions.count("GL_CHROMIUM_bind_uniform_location");
 
     if (!initializeSharedObjects())
         return false;
 
     // Make sure the viewport and context gets initialized, even if it is to zero.
     viewportChanged();
     return true;
 }
 
 CCRendererGL::~CCRendererGL()
@@ skipping 1355 matching lines @@
 }
 
 bool CCRendererGL::isContextLost()
 {
     return (m_context->getGraphicsResetStatusARB() != GraphicsContext3D::NO_ERROR);
 }
 
 } // namespace WebCore
 
 #endif // USE(ACCELERATED_COMPOSITING)