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 <limits>
 #include <public/WebGraphicsContext3D.h>
 #include <wtf/HashSet.h>
 
 using WebKit::WebGraphicsContext3D;
 
 namespace cc {
 
 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 312 matching lines @@
 }
 
 CCResourceProvider::CCResourceProvider(CCGraphicsContext* context)
     : m_context(context)
     , m_nextId(1)
     , m_nextChild(1)
     , m_defaultResourceType(GLTexture)
     , m_useTextureStorageExt(false)
     , m_useTextureUsageHint(false)
     , m_useShallowFlush(false)
-    , m_maxTextureSize(0)
+    , m_maxTextureSize(std::numeric_limits<int>::max())
 {
 }
 
-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();

[piman, 2012/09/20 01:37:01]

drive-by: what about the software case (no context3d)?

[nduca, 2012/09/20 03:49:29]

It'd be really nice if the uploader talked only to the resource provider, and
the query operations we need were just implemented by the software version of
the resource provider. David, can you do a patch after this that moves the
throttled uploader do that?

[piman, 2012/09/20 04:30:29]

My main issue though is that in software mode, we won't have a
m_textureUploader. Won't we crash when trying to do a commit? What will cause
the paints to happen and put the data into resources? What am I missing?

[reveman, 2012/09/20 04:52:18]

I think you're right. We might still need a texture uploader here but that's
fine. The main goal of this change is to get rid of TextureUploaderOption. 

UnthrottledTextureUploader can be moved to CCResourceProvider.cpp and renamed to
SoftwareTextureUploader. And I think we should do the same for TextureCopier
even though we might not use the copier in software mode at the moment.

-
         // 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));

[piman, 2012/09/20 04:30:29]

another thing, IIRC in debug, command buffers like variables for the get output
to be initialized to 0 or 1. I think this will assert unless we reset
m_maxTextureSize to 0

     return true;
 }
 
 int CCResourceProvider::createChild(int pool)
 {
     ASSERT(CCProxy::isImplThread());
     Child childInfo;
     childInfo.pool = pool;
     int child = m_nextChild++;
     m_children.add(child, childInfo);
@@ skipping 201 matching lines @@
             if (childPoolSet.contains(it->second.pool))
 #endif
                 ++maxMailboxCount;
         }
     }
     while (m_mailboxes.size() > maxMailboxCount)
         m_mailboxes.removeFirst();
 }
 
 }