cc: Maximize pending updates.

cc/resource_update_controller_unittest.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/resource_update_controller.h"
 
 #include "cc/single_thread_proxy.h" // For DebugScopedSetImplThread
 #include "cc/test/fake_web_compositor_output_surface.h"
 #include "cc/test/fake_web_graphics_context_3d.h"
 #include "cc/test/scheduler_test_common.h"
 #include "cc/test/tiled_layer_test_common.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/khronos/GLES2/gl2ext.h"
 
 using namespace cc;
 using namespace WebKit;
 using namespace WebKitTests;
 using testing::Test;
 
 namespace {
 
 const int kFlushPeriodFull = 4;
 const int kFlushPeriodPartial = kFlushPeriodFull;
@@ skipping 20 matching lines @@
                                const void* pixels);
     virtual GrGLInterface* onCreateGrGLInterface() { return 0; }
 
     virtual WebString getString(WGC3Denum name)
     {
         if (m_supportShallowFlush)
             return WebString("GL_CHROMIUM_shallow_flush");
         return WebString("");
     }
 
+    virtual void getQueryObjectuivEXT(WebGLId, WGC3Denum, WGC3Duint*);
+
 private:
     ResourceUpdateControllerTest* m_test;
     bool m_supportShallowFlush;
 };
 
 
 class ResourceUpdateControllerTest : public Test {
 public:
     ResourceUpdateControllerTest()
         : m_queue(make_scoped_ptr(new ResourceUpdateQueue))
         , m_textureManager(PrioritizedTextureManager::create(60*1024*1024, 1024, Renderer::ContentPool))
         , m_fullUploadCountExpected(0)
         , m_partialCountExpected(0)
         , m_totalUploadCountExpected(0)
         , m_maxUploadCountPerUpdate(0)
         , m_numConsecutiveFlushes(0)
         , m_numDanglingUploads(0)
         , m_numTotalUploads(0)
         , m_numTotalFlushes(0)
+        , m_queryResultsAvailable(0)
     {
     }
 
     ~ResourceUpdateControllerTest()
     {
         DebugScopedSetImplThreadAndMainThreadBlocked
             implThreadAndMainThreadBlocked;
         m_textureManager->clearAllMemory(m_resourceProvider.get());
     }
 
@@ skipping 14 matching lines @@
         if (m_numTotalUploads < m_fullUploadCountExpected)
             EXPECT_LT(m_numDanglingUploads, kFlushPeriodFull) << "Too many consecutive full uploads detected.";
         else
             EXPECT_LT(m_numDanglingUploads, kFlushPeriodPartial) << "Too many consecutive partial uploads detected.";
 
         m_numConsecutiveFlushes = 0;
         m_numDanglingUploads++;
         m_numTotalUploads++;
     }
 
+    bool isQueryResultAvailable()
+    {
+        if (!m_queryResultsAvailable)
+            return false;
+
+        m_queryResultsAvailable--;
+        return true;
+    }
+
 protected:
     virtual void SetUp()
     {
         m_context = FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new WebGraphicsContext3DForUploadTest(this)));
         m_bitmap.setConfig(SkBitmap::kARGB_8888_Config, 300, 150);
         m_bitmap.allocPixels();
 
         for (int i = 0; i < 4; i++) {
             m_textures[i] = PrioritizedTexture::create(
                 m_textureManager.get(), gfx::Size(300, 150), GL_RGBA);
@@ skipping 52 matching lines @@
             implThreadAndMainThreadBlocked;
         scoped_ptr<ResourceUpdateController> updateController =
             ResourceUpdateController::create(
                 NULL,
                 Proxy::implThread(),
                 m_queue.Pass(),
                 m_resourceProvider.get());
         updateController->finalize();
     }
 
+    void makeQueryResultAvailable()
+    {
+        m_queryResultsAvailable++;
+    }
+
 protected:
     // Classes required to interact and test the ResourceUpdateController
     scoped_ptr<GraphicsContext> m_context;
     scoped_ptr<ResourceProvider> m_resourceProvider;
     scoped_ptr<ResourceUpdateQueue> m_queue;
     scoped_ptr<PrioritizedTexture> m_textures[4];
     scoped_ptr<PrioritizedTextureManager> m_textureManager;
     SkBitmap m_bitmap;
+    int m_queryResultsAvailable;
 
     // Properties / expectations of this test
     int m_fullUploadCountExpected;
     int m_partialCountExpected;
     int m_totalUploadCountExpected;
     int m_maxUploadCountPerUpdate;
 
     // Dynamic properties of this test
     int m_numConsecutiveFlushes;
     int m_numDanglingUploads;
@@ skipping 17 matching lines @@
                                                       WGC3Dint yoffset,
                                                       WGC3Dsizei width,
                                                       WGC3Dsizei height,
                                                       WGC3Denum format,
                                                       WGC3Denum type,
                                                       const void* pixels)
 {
     m_test->onUpload();
 }
 
+void WebGraphicsContext3DForUploadTest::getQueryObjectuivEXT(
+    WebGLId,
+    WGC3Denum pname,
+    WGC3Duint* params) {
+    if (pname == GL_QUERY_RESULT_AVAILABLE_EXT)
+        *params = m_test->isQueryResultAvailable();
+}
+
 // ZERO UPLOADS TESTS
 TEST_F(ResourceUpdateControllerTest, ZeroUploads)
 {
     appendFullUploadsToUpdateQueue(0);
     appendPartialUploadsToUpdateQueue(0);
     updateTextures();
 
     EXPECT_EQ(0, m_numTotalFlushes);
     EXPECT_EQ(0, m_numTotalUploads);
 }
@@ skipping 139 matching lines @@
     controller->performMoreUpdates(
         controller->now() + base::TimeDelta::FromMilliseconds(90));
     EXPECT_FALSE(thread.hasPendingTask());
 
     controller->setUpdateMoreTexturesTime(
         base::TimeDelta::FromMilliseconds(100));
     controller->setUpdateMoreTexturesSize(1);
     // Only enough time for 1 update.
     controller->performMoreUpdates(
         controller->now() + base::TimeDelta::FromMilliseconds(120));
-    runPendingTask(&thread, controller.get());
     EXPECT_FALSE(thread.hasPendingTask());
     EXPECT_EQ(1, m_numTotalUploads);
 
+    // Complete one upload.
+    makeQueryResultAvailable();
+
     controller->setUpdateMoreTexturesTime(
         base::TimeDelta::FromMilliseconds(100));
     controller->setUpdateMoreTexturesSize(1);
     // Enough time for 2 updates.
     controller->performMoreUpdates(
         controller->now() + base::TimeDelta::FromMilliseconds(220));
     runPendingTask(&thread, controller.get());
-    runPendingTask(&thread, controller.get());
     EXPECT_FALSE(thread.hasPendingTask());
     EXPECT_TRUE(client.readyToFinalizeCalled());
     EXPECT_EQ(3, m_numTotalUploads);
 }
 
 TEST_F(ResourceUpdateControllerTest, NoMoreUpdates)
 {
     FakeResourceUpdateControllerClient client;
     FakeThread thread;
 
     setMaxUploadCountPerUpdate(1);
     appendFullUploadsToUpdateQueue(2);
     appendPartialUploadsToUpdateQueue(0);
 
     DebugScopedSetImplThreadAndMainThreadBlocked
         implThreadAndMainThreadBlocked;
     scoped_ptr<FakeResourceUpdateController> controller(FakeResourceUpdateController::create(&client, &thread, m_queue.Pass(), m_resourceProvider.get()));
 
     controller->setNow(
         controller->now() + base::TimeDelta::FromMilliseconds(1));
     controller->setUpdateMoreTexturesTime(
         base::TimeDelta::FromMilliseconds(100));
     controller->setUpdateMoreTexturesSize(1);
     // Enough time for 3 updates but only 2 necessary.
     controller->performMoreUpdates(
         controller->now() + base::TimeDelta::FromMilliseconds(310));
     runPendingTask(&thread, controller.get());
-    runPendingTask(&thread, controller.get());
     EXPECT_FALSE(thread.hasPendingTask());
     EXPECT_TRUE(client.readyToFinalizeCalled());
     EXPECT_EQ(2, m_numTotalUploads);
 
     controller->setUpdateMoreTexturesTime(
         base::TimeDelta::FromMilliseconds(100));
     controller->setUpdateMoreTexturesSize(1);
     // Enough time for updates but no more updates left.
     controller->performMoreUpdates(
         controller->now() + base::TimeDelta::FromMilliseconds(310));
@@ skipping 34 matching lines @@
         if (thread.hasPendingTask())
             runPendingTask(&thread, controller.get());
     }
 
     EXPECT_FALSE(thread.hasPendingTask());
     EXPECT_TRUE(client.readyToFinalizeCalled());
     EXPECT_EQ(2, m_numTotalUploads);
 }
 
 }  // anonymous namespace