cc: Remove TextureUploaderOption.

cc/CCResourceProvider.cpp

 // Copyright 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 "config.h"
 
 #include "CCResourceProvider.h"
 #ifdef LOG
 #undef LOG
 #endif
 
 #include <limits.h>
 
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "CCProxy.h"
 #include "CCRendererGL.h" // For the GLC() macro.
 #include "Extensions3DChromium.h"
 #include "IntRect.h"
 #include "LayerTextureSubImage.h"
 #include "ThrottledTextureUploader.h"
-#include "UnthrottledTextureUploader.h"
 #include <public/WebGraphicsContext3D.h>
 #include <wtf/HashSet.h>
 
 using WebKit::WebGraphicsContext3D;
 
 namespace cc {
 
+class SoftwareTextureUploader : public TextureUploader {

[nduca, 2012/09/20 18:34:17]

One class per file, please.

[piman, 2012/09/20 18:48:42]

FYI, in chrome code having multiple private classes in .cc files is considered
ok - though it's better to put it in an anonymous namespace to make sure to
avoid collisions.

If you guys want a stricter set of local rules, that's fine, but I suggest then
to document that in a STYLE or README file at the cc/ top level.

+public:
+    virtual bool isBusy() OVERRIDE { return false; }
+    virtual double estimatedTexturesPerSecond() { return std::numeric_limits<double>::max(); }
+    virtual void beginUploads() OVERRIDE { }
+    virtual void endUploads() OVERRIDE { }
+    virtual void uploadTexture(CCResourceProvider* resourceProvider, Parameters upload) OVERRIDE { upload.texture->updateRect(resourceProvider, upload.sourceRect, upload.destOffset); }
+};
+
 static GC3Denum textureToStorageFormat(GC3Denum textureFormat)
 {
     GC3Denum storageFormat = Extensions3D::RGBA8_OES;
     switch (textureFormat) {
     case GraphicsContext3D::RGBA:
         break;
     case Extensions3D::BGRA_EXT:
         storageFormat = Extensions3DChromium::BGRA8_EXT;
         break;
     default:
         ASSERT_NOT_REACHED();
         break;
     }
 
     return storageFormat;
 }
 
 static bool isTextureFormatSupportedForStorage(GC3Denum format)
 {
     return (format == GraphicsContext3D::RGBA || format == Extensions3D::BGRA_EXT);
 }
 
-PassOwnPtr<CCResourceProvider> CCResourceProvider::create(CCGraphicsContext* context, TextureUploaderOption option)
+PassOwnPtr<CCResourceProvider> CCResourceProvider::create(CCGraphicsContext* context)
 {
     OwnPtr<CCResourceProvider> resourceProvider(adoptPtr(new CCResourceProvider(context)));
-    if (!resourceProvider->initialize(option))
+    if (!resourceProvider->initialize())
         return nullptr;
     return resourceProvider.release();
 }
 
 CCResourceProvider::~CCResourceProvider()
 {
     WebGraphicsContext3D* context3d = m_context->context3D();
     if (!context3d || !context3d->makeContextCurrent())
         return;
     m_textureUploader.clear();
@@ skipping 316 matching lines @@
     , m_nextId(1)
     , m_nextChild(1)
     , m_defaultResourceType(GLTexture)
     , m_useTextureStorageExt(false)
     , m_useTextureUsageHint(false)
     , m_useShallowFlush(false)
     , m_maxTextureSize(0)
 {
 }
 
-bool CCResourceProvider::initialize(TextureUploaderOption textureUploaderOption)
+bool CCResourceProvider::initialize()
 {
     ASSERT(CCProxy::isImplThread());
     WebGraphicsContext3D* context3d = m_context->context3D();
     if (!context3d) {
         m_maxTextureSize = INT_MAX;
-        m_textureUploader = UnthrottledTextureUploader::create();
+        m_textureUploader = adoptPtr(new SoftwareTextureUploader);
 
         // FIXME: Implement this path for software compositing.
         return false;
     }
     if (!context3d->makeContextCurrent())
         return false;
 
     std::string extensionsString = UTF16ToASCII(context3d->getString(GraphicsContext3D::EXTENSIONS));
     std::vector<std::string> extensions;
     base::SplitString(extensionsString, ' ', &extensions);
     bool useMapSub = false;
     bool useBindUniform = false;
     for (size_t i = 0; i < extensions.size(); ++i) {
         if (extensions[i] == "GL_EXT_texture_storage")
             m_useTextureStorageExt = true;
         else if (extensions[i] == "GL_ANGLE_texture_usage")
             m_useTextureUsageHint = true;
         else if (extensions[i] == "GL_CHROMIUM_map_sub")
             useMapSub = true;
         else if (extensions[i] == "GL_CHROMIUM_shallow_flush")
             m_useShallowFlush = true;
         else if (extensions[i] == "GL_CHROMIUM_bind_uniform_location")
             useBindUniform = true;
     }
 
     m_texSubImage = adoptPtr(new LayerTextureSubImage(useMapSub));
     m_textureCopier = AcceleratedTextureCopier::create(context3d, useBindUniform);
 
-    if (textureUploaderOption == ThrottledUploader)
-        m_textureUploader = ThrottledTextureUploader::create(context3d);
-    else
-        m_textureUploader = UnthrottledTextureUploader::create();
+    m_textureUploader = ThrottledTextureUploader::create(context3d);
     GLC(context3d, context3d->getIntegerv(GraphicsContext3D::MAX_TEXTURE_SIZE, &m_maxTextureSize));
     return true;
 }
 
 int CCResourceProvider::createChild(int pool)
 {
     ASSERT(CCProxy::isImplThread());
     Child childInfo;
     childInfo.pool = pool;
     int child = m_nextChild++;
@@ skipping 202 matching lines @@
             if (childPoolSet.contains(it->second.pool))
 #endif
                 ++maxMailboxCount;
         }
     }
     while (m_mailboxes.size() > maxMailboxCount)
         m_mailboxes.removeFirst();
 }
 
 }