Move TextureCopier and TextureUploader from CCRenderer to CCResourceProvider

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"
 
 #include "CCDamageTracker.h"
 #include "CCLayerQuad.h"
 #include "CCMathUtil.h"
 #include "CCProxy.h"
 #include "CCRenderPass.h"
 #include "CCRenderSurfaceFilters.h"
 #include "CCScopedTexture.h"
 #include "CCSettings.h"
 #include "CCSingleThreadProxy.h"
 #include "CCVideoLayerImpl.h"
 #include "Extensions3D.h"
 #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 "base/string_util.h"
 #include <public/WebGraphicsContext3D.h>
 #include <public/WebSharedGraphicsContext3D.h>
 #include <public/WebVideoFrame.h>
 #include <set>
 #include <string>
@@ skipping 15 matching lines @@
 {
 #if OS(DARWIN)
     return true;
 #else
     return false;
 #endif
 }
 
 } // anonymous namespace
 
-PassOwnPtr<CCRendererGL> CCRendererGL::create(CCRendererClient* client, CCResourceProvider* resourceProvider, TextureUploaderOption textureUploaderSetting)
+PassOwnPtr<CCRendererGL> CCRendererGL::create(CCRendererClient* client, CCResourceProvider* resourceProvider)
 {
-    OwnPtr<CCRendererGL> renderer(adoptPtr(new CCRendererGL(client, resourceProvider, textureUploaderSetting)));
+    OwnPtr<CCRendererGL> renderer(adoptPtr(new CCRendererGL(client, resourceProvider)));
     if (!renderer->initialize())
         return nullptr;
 
     return renderer.release();
 }
 
 CCRendererGL::CCRendererGL(CCRendererClient* client,
-                                             CCResourceProvider* resourceProvider,
-                                             TextureUploaderOption textureUploaderSetting)
+                           CCResourceProvider* resourceProvider)
     : CCDirectRenderer(client, resourceProvider)
     , m_offscreenFramebufferId(0)
     , m_sharedGeometryQuad(FloatRect(-0.5f, -0.5f, 1.0f, 1.0f))
     , m_context(resourceProvider->graphicsContext3D())
     , m_isViewportChanged(false)
     , m_isFramebufferDiscarded(false)
     , m_isUsingBindUniform(false)
     , m_visible(true)
-    , m_textureUploaderSetting(textureUploaderSetting)
 {
     ASSERT(m_context);
 }
 
 bool CCRendererGL::initialize()
 {
     if (!m_context->makeContextCurrent())
         return false;
 
     m_context->setContextLostCallback(this);
@@ skipping 1168 matching lines @@
 
     // We will always need these programs to render, so create the programs eagerly so that the shader compilation can
     // start while we do other work. Other programs are created lazily on first access.
     m_sharedGeometry = adoptPtr(new GeometryBinding(m_context, quadVertexRect()));
     m_renderPassProgram = adoptPtr(new RenderPassProgram(m_context));
     m_tileProgram = adoptPtr(new TileProgram(m_context));
     m_tileProgramOpaque = adoptPtr(new TileProgramOpaque(m_context));
 
     GLC(m_context, m_context->flush());
 
-    m_textureCopier = AcceleratedTextureCopier::create(m_context, m_isUsingBindUniform);
-    if (m_textureUploaderSetting == ThrottledUploader)
-        m_textureUploader = ThrottledTextureUploader::create(m_context);
-    else
-        m_textureUploader = UnthrottledTextureUploader::create();
-
     return true;
 }
 
 const CCRendererGL::TileCheckerboardProgram* CCRendererGL::tileCheckerboardProgram()
 {
     if (!m_tileCheckerboardProgram)
         m_tileCheckerboardProgram = adoptPtr(new TileCheckerboardProgram(m_context));
     if (!m_tileCheckerboardProgram->initialized()) {
         TRACE_EVENT0("cc", "CCRendererGL::checkerboardProgram::initalize");
         m_tileCheckerboardProgram->initialize(m_context, m_isUsingBindUniform);
@@ skipping 215 matching lines @@
         m_videoYUVProgram->cleanup(m_context);
     if (m_videoStreamTextureProgram)
         m_videoStreamTextureProgram->cleanup(m_context);
 
     if (m_solidColorProgram)
         m_solidColorProgram->cleanup(m_context);
 
     if (m_offscreenFramebufferId)
         GLC(m_context, m_context->deleteFramebuffer(m_offscreenFramebufferId));
 
-    m_textureCopier.clear();
-    m_textureUploader.clear();
-
     releaseRenderPassTextures();
 }
 
 bool CCRendererGL::isContextLost()
 {
     return (m_context->getGraphicsResetStatusARB() != GraphicsContext3D::NO_ERROR);
 }
 
 } // namespace cc
 
 #endif // USE(ACCELERATED_COMPOSITING)