cc: Move textureUploadFlushPeriod to TextureUploader.

cc/texture_uploader.cc

 // 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 "cc/texture_uploader.h"
 
 #include <algorithm>
 #include <vector>
@@ skipping 13 matching lines @@
 
 // How many previous uploads to use when predicting future throughput.
 static const size_t uploadHistorySizeMax = 1000;
 static const size_t uploadHistorySizeInitial = 100;
 
 // Global estimated number of textures per second to maintain estimates across
 // subsequent instances of TextureUploader.
 // More than one thread will not access this variable, so we do not need to synchronize access.
 static const double defaultEstimatedTexturesPerSecond = 48.0 * 60.0;
 
+// Flush interval when performing texture uploads.
+const int textureUploadFlushPeriod = 4;
+
 } // anonymous namespace
 
 namespace cc {
 
 TextureUploader::Query::Query(WebKit::WebGraphicsContext3D* context)
     : m_context(context)
     , m_queryId(0)
     , m_value(0)
     , m_hasValue(false)
     , m_isNonBlocking(false)
@@ skipping 38 matching lines @@
 {
     m_isNonBlocking = true;
 }
 
 bool TextureUploader::Query::isNonBlocking()
 {
     return m_isNonBlocking;
 }
 
 TextureUploader::TextureUploader(
-    WebKit::WebGraphicsContext3D* context, bool useMapTexSubImage)
+    WebKit::WebGraphicsContext3D* context,
+    bool useMapTexSubImage,
+    bool useShallowFlush)
     : m_context(context)
     , m_numBlockingTextureUploads(0)
     , m_useMapTexSubImage(useMapTexSubImage)
     , m_subImageSize(0)
+    , m_useShallowFlush(useShallowFlush)
+    , m_numTextureUploadsSinceLastFlush(0)
 {
     for (size_t i = uploadHistorySizeInitial; i > 0; i--)
         m_texturesPerSecondHistory.insert(defaultEstimatedTexturesPerSecond);
 }
 
 TextureUploader::~TextureUploader()
 {
 }
 
 size_t TextureUploader::numBlockingUploads()
@@ skipping 59 matching lines @@
     if (m_useMapTexSubImage) {
         uploadWithMapTexSubImage(
             image, image_rect, source_rect, dest_offset, format);
     } else {
         uploadWithTexSubImage(
             image, image_rect, source_rect, dest_offset, format);
     }
 
     if (isFullUpload)
         endQuery();
+
+    m_numTextureUploadsSinceLastFlush++;
+    if (m_numTextureUploadsSinceLastFlush >= textureUploadFlushPeriod)
+      flush();
+}
+
+void TextureUploader::flush() {
+  if (!m_numTextureUploadsSinceLastFlush)
+    return;
+
+  if (m_useShallowFlush)
+    m_context->shallowFlushCHROMIUM();
+
+  m_numTextureUploadsSinceLastFlush = 0;
 }
 
 void TextureUploader::uploadWithTexSubImage(const uint8* image,
                                             const gfx::Rect& image_rect,
                                             const gfx::Rect& source_rect,
                                             const gfx::Vector2d& dest_offset,
                                             GLenum format)
 {
     // Instrumentation to debug issue 156107
     int source_rect_x = source_rect.x();
@@ skipping 144 matching lines @@
             m_texturesPerSecondHistory.erase(m_texturesPerSecondHistory.begin());
             m_texturesPerSecondHistory.erase(--m_texturesPerSecondHistory.end());
         }
         m_texturesPerSecondHistory.insert(texturesPerSecond);
 
         m_availableQueries.append(m_pendingQueries.takeFirst());
     }
 }
 
 }