Employ the transfer queue to the pure color tiles

This fixed the sync problem for the pure color tiles.
When Tex Gen thread detect that the tile is pure color, UI need to pick it up
in the right time. To avoid adding too many sync object, the simplest way is
following the same idea of transfer queue.
At the same time, using a separate queue and adding simple operation on top of
it can limit the impact to the original transfer queue which is highly coupled
with SurfTex implemenation.

bug:5808996

Change-Id: I518d358c5626815b27f285d4dcadcee9c3234835

9 files changed, 132 insertions, 80 deletions

diff --git a/Source/WebCore/platform/graphics/android/BaseTile.cpp b/Source/WebCore/platform/graphics/android/BaseTile.cpp
index ea546ef..76ee1e7 100644
--- a/Source/WebCore/platform/graphics/android/BaseTile.cpp
+++ b/Source/WebCore/platform/graphics/android/BaseTile.cpp
@@ -124,7 +124,6 @@ void BaseTile::reserveTexture()
              this, texture, m_backTexture, m_frontTexture);
         m_state = Unpainted;
         m_backTexture = texture;
-        m_backTexture->setPure(false);
     }
 
     if (m_state == UpToDate) {
@@ -247,30 +246,9 @@ void BaseTile::draw(float transparency, SkRect& rect, float scale)
     if (!isTexturePainted)
         return;
 
-    if (m_frontTexture->readyFor(this)) {
-        if (isLayerTile() && m_painter && m_painter->transform()) {
-            if (m_frontTexture->isPureColor()) {
-                TilesManager::instance()->shader()->drawLayerQuad(*m_painter->transform(),
-                                                                  rect, 0,
-                                                                  transparency, true,
-                                                                  GL_TEXTURE_2D,
-                                                                  m_frontTexture->pureColor());
-            } else {
-                TilesManager::instance()->shader()->drawLayerQuad(*m_painter->transform(),
-                                                                  rect, m_frontTexture->m_ownTextureId,
-                                                                  transparency, true);
-            }
-        } else {
-             if (m_frontTexture->isPureColor()) {
-                 TilesManager::instance()->shader()->drawQuad(rect, 0,
-                                                              transparency,
-                                                              m_frontTexture->pureColor());
-             } else {
-                TilesManager::instance()->shader()->drawQuad(rect, m_frontTexture->m_ownTextureId,
-                                                             transparency);
-            }
-        }
-    } else {
+    if (m_frontTexture->readyFor(this))
+        m_frontTexture->draw(isLayerTile(), m_painter, rect, transparency);
+    else {
         XLOG("tile %p at %d, %d not readyfor (at draw),", this, m_x, m_y);
     }
 }
@@ -555,8 +533,7 @@ void BaseTile::validatePaint() {
         // when both have happened, mark as 'ReadyToSwap'
         if (m_state == PaintingStarted)
             m_state = ValidatedUntransferred;
-        else if (m_state == TransferredUnvalidated
-                 || (m_backTexture && m_backTexture->isPureColor())) {
+        else if (m_state == TransferredUnvalidated) {
             // When the backTexture has been marked pureColor, we will skip the
             // transfer and marked as ReadyToSwap, in this case, we don't want
             // to reset m_dirty bit to true.
diff --git a/Source/WebCore/platform/graphics/android/BaseTileTexture.cpp b/Source/WebCore/platform/graphics/android/BaseTileTexture.cpp
index ae6f1e8..b3a6b84 100644
--- a/Source/WebCore/platform/graphics/android/BaseTileTexture.cpp
+++ b/Source/WebCore/platform/graphics/android/BaseTileTexture.cpp
@@ -149,12 +149,14 @@ void BaseTileTexture::setOwnTextureTileInfoFromQueue(const TextureTileInfo* info
 
 bool BaseTileTexture::readyFor(BaseTile* baseTile)
 {
-    if (isPureColor()) {
+    const TextureTileInfo* info = &m_ownTextureTileInfo;
+
+    if (isPureColor() && info->m_painter == baseTile->painter()) {
         XLOG("ReadyFor saw a pureColor tile (%p) at (%d, %d), rgb %x",
               this, baseTile->x(), baseTile->y(), pureColor().rgb());
         return true;
     }
-    const TextureTileInfo* info = &m_ownTextureTileInfo;
+
     if (info &&
         (info->m_x == baseTile->x()) &&
         (info->m_y == baseTile->y()) &&
@@ -170,4 +172,24 @@ bool BaseTileTexture::readyFor(BaseTile* baseTile)
     return false;
 }
 
+void BaseTileTexture::draw(bool isLayer, TilePainter* painter,
+                           SkRect& rect, float transparency)
+{
+    ShaderProgram* shader = TilesManager::instance()->shader();
+    if (isLayer && painter && painter->transform()) {
+        if (isPureColor()) {
+            shader->drawLayerQuad(*painter->transform(), rect, 0, transparency,
+                                  true, GL_TEXTURE_2D, pureColor());
+        } else {
+            shader->drawLayerQuad(*painter->transform(), rect, m_ownTextureId,
+                                  transparency, true);
+        }
+    } else {
+         if (isPureColor())
+             shader->drawQuad(rect, 0,transparency, pureColor());
+         else
+            shader->drawQuad(rect, m_ownTextureId, transparency);
+    }
+}
+
 } // namespace WebCore
diff --git a/Source/WebCore/platform/graphics/android/BaseTileTexture.h b/Source/WebCore/platform/graphics/android/BaseTileTexture.h
index 74f9e5d..55314c7 100644
--- a/Source/WebCore/platform/graphics/android/BaseTileTexture.h
+++ b/Source/WebCore/platform/graphics/android/BaseTileTexture.h
@@ -95,12 +95,15 @@ public:
 
     TextureInfo* getTextureInfo() { return &m_ownTextureInfo; }
 
-    void setPure(bool pure){ m_isPureColor = pure; }
+    // Make sure the following pureColor getter/setter are only read/written
+    // in UI thread. Therefore no need for a lock.
+    void setPure(bool pure) { m_isPureColor = pure; }
     bool isPureColor() {return m_isPureColor; }
-
-    void setPureColor(const Color& color) { m_pureColor = color; }
+    void setPureColor(const Color& color) { m_pureColor = color; setPure(true); }
     Color pureColor() { return m_pureColor; }
 
+    void draw(bool isLayer, TilePainter* painter, SkRect& rect,
+              float transparency);
 private:
     TextureTileInfo m_ownTextureTileInfo;
     // TODO: Merge this info into the TextureTileInfo.
diff --git a/Source/WebCore/platform/graphics/android/GLUtils.cpp b/Source/WebCore/platform/graphics/android/GLUtils.cpp
index 38e1ce9..2d18032 100644
--- a/Source/WebCore/platform/graphics/android/GLUtils.cpp
+++ b/Source/WebCore/platform/graphics/android/GLUtils.cpp
@@ -387,6 +387,9 @@ bool GLUtils::isPureColorBitmap(const SkBitmap& bitmap, Color& pureColor)
     int bitmapWidth = bitmap.width();
 
     // Create a row of pure color using the first pixel.
+    // TODO: improve the perf here, by either picking a random pixel, or
+    // creating an array of rows with pre-defined commonly used color, add
+    // smart LUT to speed things up if possible.
     int* firstPixelPtr = static_cast<int*> (bitmap.getPixels());
     int* pixelsRow = new int[bitmapWidth];
     for (int i = 0; i < bitmapWidth; i++)
@@ -424,31 +427,17 @@ bool GLUtils::skipTransferForPureColor(const TileRenderInfo* renderInfo,
         BaseTileTexture* tileTexture = tilePtr->backTexture();
         // Check the bitmap, and make everything ready here.
         Color pureColor;
-        bool pure = isPureColorBitmap(bitmap, pureColor);
-        if (pure) {
+        if (tileTexture && isPureColorBitmap(bitmap, pureColor)) {
             // update basetile's info
             // Note that we are skipping the whole TransferQueue.
-            if (tileTexture) {
-                tileTexture->setPure(true);
-                tileTexture->setPureColor(pureColor);
-
-                TextureTileInfo info;
-                // Now fill the tileInfo.
-                info.m_x = renderInfo->x;
-                info.m_y = renderInfo->y;
-                info.m_scale = renderInfo->scale;
-                info.m_painter = renderInfo->tilePainter;
-                info.m_picture = renderInfo->textureInfo->m_pictureCount;
-                info.m_inverted = TilesManager::instance()->invertedScreen();
-
-                // Make sure the tile is considered ready!
-                tileTexture->setOwnTextureTileInfoFromQueue(&info);
-
-                renderInfo->textureInfo->m_width = bitmap.width();
-                renderInfo->textureInfo->m_height = bitmap.height();
-                renderInfo->textureInfo->m_internalFormat = GL_RGBA;
-                skipTransfer = true;
-            }
+            renderInfo->textureInfo->m_width = bitmap.width();
+            renderInfo->textureInfo->m_height = bitmap.height();
+            renderInfo->textureInfo->m_internalFormat = GL_RGBA;
+
+            TilesManager::instance()->transferQueue()->addItemInPureColorQueue(renderInfo,
+                                                                               pureColor);
+
+            skipTransfer = true;
         }
     }
     return skipTransfer;
diff --git a/Source/WebCore/platform/graphics/android/GLWebViewState.cpp b/Source/WebCore/platform/graphics/android/GLWebViewState.cpp
index 89f1d27..ece019c 100644
--- a/Source/WebCore/platform/graphics/android/GLWebViewState.cpp
+++ b/Source/WebCore/platform/graphics/android/GLWebViewState.cpp
@@ -354,7 +354,7 @@ double GLWebViewState::setupDrawing(IntRect& viewRect, SkRect& visibleRect,
     int height = viewRect.height();
 
     ShaderProgram* shader = TilesManager::instance()->shader();
-    if (shader->needInit()) {
+    if (shader->needsInit()) {
         XLOG("Reinit shader");
         shader->init();
     }
diff --git a/Source/WebCore/platform/graphics/android/ShaderProgram.cpp b/Source/WebCore/platform/graphics/android/ShaderProgram.cpp
index e7d9434..62c00e7 100644
--- a/Source/WebCore/platform/graphics/android/ShaderProgram.cpp
+++ b/Source/WebCore/platform/graphics/android/ShaderProgram.cpp
@@ -217,7 +217,7 @@ ShaderProgram::ShaderProgram()
     , m_contrast(1)
     , m_alphaLayer(false)
     , m_currentScale(1.0f)
-    , m_needInit(true)
+    , m_needsInit(true)
 {
     init();
 }
@@ -239,10 +239,10 @@ void ShaderProgram::init()
         || videoProgram == -1
         || texOESProgram == -1
         || texOESInvProgram == -1) {
-        m_needInit = true;
+        m_needsInit = true;
         return;
     }
-    m_needInit = false;
+    m_needsInit = false;
 
     GLint pureColorPosition = glGetAttribLocation(pureColorProgram, "vPosition");
     GLint pureColorProjMtx = glGetUniformLocation(pureColorProgram, "projectionMatrix");
diff --git a/Source/WebCore/platform/graphics/android/ShaderProgram.h b/Source/WebCore/platform/graphics/android/ShaderProgram.h
index 1bb40a4..3d7aab5 100644
--- a/Source/WebCore/platform/graphics/android/ShaderProgram.h
+++ b/Source/WebCore/platform/graphics/android/ShaderProgram.h
@@ -147,7 +147,7 @@ public:
     void calculateAnimationDelta();
     int getAnimationDeltaX() { return m_animationDelta.x(); }
     int getAnimationDeltaY() { return m_animationDelta.y(); }
-    bool needInit() { return m_needInit; }
+    bool needsInit() { return m_needsInit; }
 
 private:
     GLuint loadShader(GLenum shaderType, const char* pSource);
@@ -201,7 +201,7 @@ private:
 
     // If there is any GL error happens such that the Shaders are not initialized
     // successfully at the first time, then we need to init again when we draw.
-    bool m_needInit;
+    bool m_needsInit;
 
     // For transfer queue blitting, we need a special matrix map from (0,1) to
     // (-1,1)
diff --git a/Source/WebCore/platform/graphics/android/TransferQueue.cpp b/Source/WebCore/platform/graphics/android/TransferQueue.cpp
index bb7ed9b..5d47629 100644
--- a/Source/WebCore/platform/graphics/android/TransferQueue.cpp
+++ b/Source/WebCore/platform/graphics/android/TransferQueue.cpp
@@ -118,9 +118,9 @@ void TransferQueue::initSharedSurfaceTextures(int width, int height)
 // When bliting, if the item from the transfer queue is mismatching b/t the
 // BaseTile and the content, then the item is considered as obsolete, and
 // the content is discarded.
-bool TransferQueue::checkObsolete(int index)
+bool TransferQueue::checkObsolete(const TileTransferData* data)
 {
-    BaseTile* baseTilePtr = m_transferQueue[index].savedBaseTilePtr;
+    BaseTile* baseTilePtr = data->savedBaseTilePtr;
     if (!baseTilePtr) {
         XLOG("Invalid savedBaseTilePtr , such that the tile is obsolete");
         return true;
@@ -132,7 +132,7 @@ bool TransferQueue::checkObsolete(int index)
         return true;
     }
 
-    const TextureTileInfo* tileInfo = &m_transferQueue[index].tileInfo;
+    const TextureTileInfo* tileInfo = &(data->tileInfo);
 
     if (tileInfo->m_x != baseTilePtr->x()
         || tileInfo->m_y != baseTilePtr->y()
@@ -269,6 +269,8 @@ void TransferQueue::discardQueue()
         if (m_transferQueue[i].status == pendingBlit)
             m_transferQueue[i].status = pendingDiscard;
 
+    m_pureColorTileQueue.clear();
+
     bool GLContextExisted = getHasGLContext();
     // Unblock the Tex Gen thread first before Tile Page deletion.
     // Otherwise, there will be a deadlock while removing operations.
@@ -279,6 +281,26 @@ void TransferQueue::discardQueue()
         m_transferQueueItemCond.signal();
 }
 
+void TransferQueue::updatePureColorTiles()
+{
+    for (unsigned int i = 0 ; i < m_pureColorTileQueue.size(); i++) {
+        TileTransferData* data = &m_pureColorTileQueue[i];
+        if (data->status == pendingBlit) {
+            BaseTileTexture* destTexture = 0;
+            bool obsoleteBaseTile = checkObsolete(data);
+            if (!obsoleteBaseTile) {
+                destTexture = data->savedBaseTilePtr->backTexture();
+                destTexture->setPureColor(data->pureColor);
+                destTexture->setOwnTextureTileInfoFromQueue(&data->tileInfo);
+            }
+        } else if (data->status == emptyItem || data->status == pendingDiscard) {
+            // The queue should be clear instead of setting to different status.
+            XLOG("Warning: Don't expect an emptyItem here.");
+        }
+    }
+    m_pureColorTileQueue.clear();
+}
+
 // Call on UI thread to copy from the shared Surface Texture to the BaseTile's texture.
 void TransferQueue::updateDirtyBaseTiles()
 {
@@ -288,6 +310,9 @@ void TransferQueue::updateDirtyBaseTiles()
     if (!getHasGLContext())
         setHasGLContext(true);
 
+    // Check the pure color tile first, since it is simpler.
+    updatePureColorTiles();
+
     // Start from the oldest item, we call the updateTexImage to retrive
     // the texture and blit that into each BaseTile's texture.
     const int nextItemIndex = getNextTransferQueueIndex();
@@ -295,7 +320,7 @@ void TransferQueue::updateDirtyBaseTiles()
     bool usedFboForUpload = false;
     for (int k = 0; k < ST_BUFFER_NUMBER ; k++) {
         if (m_transferQueue[index].status == pendingBlit) {
-            bool obsoleteBaseTile = checkObsolete(index);
+            bool obsoleteBaseTile = checkObsolete(&m_transferQueue[index]);
             // Save the needed info, update the Surf Tex, clean up the item in
             // the queue. Then either move on to next item or copy the content.
             BaseTileTexture* destTexture = 0;
@@ -337,6 +362,7 @@ void TransferQueue::updateDirtyBaseTiles()
             // will find the latest texture's info
             // We don't need a map any more, each texture contains its own
             // texturesTileInfo.
+            destTexture->setPure(false);
             destTexture->setOwnTextureTileInfoFromQueue(&m_transferQueue[index].tileInfo);
 
             XLOG("Blit tile x, y %d %d with dest texture %p to destTexture->m_ownTextureId %d",
@@ -433,6 +459,39 @@ bool TransferQueue::tryUpdateQueueWithBitmap(const TileRenderInfo* renderInfo,
     return true;
 }
 
+void TransferQueue::addItemInPureColorQueue(const TileRenderInfo* renderInfo, Color color)
+{
+    // The pure color tiles' queue will be read from UI thread and written in
+    // Tex Gen thread, thus we need to have a lock here.
+    android::Mutex::Autolock lock(m_transferQueueItemLocks);
+    TileTransferData data;
+    addItemCommon(renderInfo, GpuUpload, &data);
+    data.pureColor = color;
+    m_pureColorTileQueue.append(data);
+}
+
+// Translates the info from TileRenderInfo and others to TileTransferData.
+// This is used by pure color tiles and normal tiles.
+void TransferQueue::addItemCommon(const TileRenderInfo* renderInfo,
+                                  TextureUploadType type,
+                                  TileTransferData* data)
+{
+    data->savedBaseTileTexturePtr = renderInfo->baseTile->backTexture();
+    data->savedBaseTilePtr = renderInfo->baseTile;
+    data->status = pendingBlit;
+    data->uploadType = type;
+
+    // Now fill the tileInfo.
+    TextureTileInfo* textureInfo = &(data->tileInfo);
+
+    textureInfo->m_x = renderInfo->x;
+    textureInfo->m_y = renderInfo->y;
+    textureInfo->m_scale = renderInfo->scale;
+    textureInfo->m_painter = renderInfo->tilePainter;
+
+    textureInfo->m_picture = renderInfo->textureInfo->m_pictureCount;
+}
+
 // Note that there should be lock/unlock around this function call.
 // Currently only called by GLUtils::updateSharedSurfaceTextureWithBitmap.
 void TransferQueue::addItemInTransferQueue(const TileRenderInfo* renderInfo,
@@ -447,10 +506,8 @@ void TransferQueue::addItemInTransferQueue(const TileRenderInfo* renderInfo,
         XLOG("ERROR update a tile which is dirty already @ index %d", index);
     }
 
-    m_transferQueue[index].savedBaseTileTexturePtr = renderInfo->baseTile->backTexture();
-    m_transferQueue[index].savedBaseTilePtr = renderInfo->baseTile;
-    m_transferQueue[index].status = pendingBlit;
-    m_transferQueue[index].uploadType = type;
+    TileTransferData* data = &m_transferQueue[index];
+    addItemCommon(renderInfo, type, data);
     if (type == CpuUpload && bitmap) {
         // Lazily create the bitmap
         if (!m_transferQueue[index].bitmap) {
@@ -462,16 +519,6 @@ void TransferQueue::addItemInTransferQueue(const TileRenderInfo* renderInfo,
         bitmap->copyTo(m_transferQueue[index].bitmap, bitmap->config());
     }
 
-    // Now fill the tileInfo.
-    TextureTileInfo* textureInfo = &m_transferQueue[index].tileInfo;
-
-    textureInfo->m_x = renderInfo->x;
-    textureInfo->m_y = renderInfo->y;
-    textureInfo->m_scale = renderInfo->scale;
-    textureInfo->m_painter = renderInfo->tilePainter;
-
-    textureInfo->m_picture = renderInfo->textureInfo->m_pictureCount;
-
     m_emptyItemCount--;
 }
 
diff --git a/Source/WebCore/platform/graphics/android/TransferQueue.h b/Source/WebCore/platform/graphics/android/TransferQueue.h
index b33a576..629935f 100644
--- a/Source/WebCore/platform/graphics/android/TransferQueue.h
+++ b/Source/WebCore/platform/graphics/android/TransferQueue.h
@@ -93,6 +93,9 @@ public:
     // lazily allocated.
     SkBitmap* bitmap;
 
+    // Specific data to the pure color tiles' queue.
+    Color pureColor;
+
     // Sync object for GPU fence, this is the only the info passed from UI
     // thread to Tex Gen thread. The reason of having this is due to the
     // missing sync mechanism on Surface Texture on some vendor. b/5122031.
@@ -133,6 +136,8 @@ public:
     void lockQueue() { m_transferQueueItemLocks.lock(); }
     void unlockQueue() { m_transferQueueItemLocks.unlock(); }
 
+    void addItemInPureColorQueue(const TileRenderInfo* renderInfo, Color color);
+
     // This queue can be accessed from UI and TexGen thread, therefore, we need
     // a lock to protect its access
     TileTransferData* m_transferQueue;
@@ -157,7 +162,7 @@ private:
     void restoreGLState();
 
     // Check the current transfer queue item is obsolete or not.
-    bool checkObsolete(int index);
+    bool checkObsolete(const TileTransferData* data);
 
     // Before each draw call and the blit operation, clean up all the
     // pendingDiscard items.
@@ -167,6 +172,10 @@ private:
                            GLuint srcTexId, GLenum srcTexTarget,
                            int index);
 
+    void addItemCommon(const TileRenderInfo* renderInfo,
+                       TextureUploadType type, TileTransferData* data);
+
+    void updatePureColorTiles();
     // Note that the m_transferQueueIndex only changed in the TexGen thread
     // where we are going to move on to update the next item in the queue.
     int m_transferQueueIndex;
@@ -202,6 +211,11 @@ private:
     // This should be GpuUpload for production, but for debug purpose or working
     // around driver/HW issue, we can set it to CpuUpload.
     TextureUploadType m_currentUploadType;
+
+    // The non-pure-color tile are 1 to 1 mapping with Surface Texture which is
+    // resource limited. To get better performance, it is better to separate
+    // the pure color tile into another queue.
+    WTF::Vector<TileTransferData> m_pureColorTileQueue;
 };
 
 } // namespace WebCore