Add CCDelegatingRenderer, and corresponding IPCs

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/debug/alias.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
+#include "cc/transferable_resource.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 <public/WebGraphicsContext3D.h>
 #include <wtf/HashSet.h>
 
@@ skipping 16 matching lines @@
     }
 
     return storageFormat;
 }
 
 static bool isTextureFormatSupportedForStorage(GC3Denum format)
 {
     return (format == GraphicsContext3D::RGBA || format == Extensions3D::BGRA_EXT);
 }
 
-CCResourceProvider::TransferableResourceList::TransferableResourceList()
-{
-}
-
-CCResourceProvider::TransferableResourceList::~TransferableResourceList()
-{
-}
-
 CCResourceProvider::Resource::Resource()
     : glId(0)
     , pixels(0)
     , pool(0)
     , lockForReadCount(0)
     , lockedForWrite(false)
     , external(false)
     , exported(false)
-    , markedForDeletion(false)
+    , deleted(false)
     , size()
     , format(0)
     , type(static_cast<ResourceType>(0))
 {
 }
 
 CCResourceProvider::Resource::Resource(unsigned textureId, int pool, const IntSize& size, GC3Denum format)
     : glId(textureId)
     , pixels(0)
     , pool(pool)
     , lockForReadCount(0)
     , lockedForWrite(false)
     , external(false)
     , exported(false)
-    , markedForDeletion(false)
+    , deleted(false)
     , size(size)
     , format(format)
     , type(GLTexture)
 {
 }
 
 CCResourceProvider::Resource::Resource(uint8_t* pixels, int pool, const IntSize& size, GC3Denum format)
     : glId(0)
     , pixels(pixels)
     , pool(pool)
     , lockForReadCount(0)
     , lockedForWrite(false)
     , external(false)
     , exported(false)
-    , markedForDeletion(false)
+    , deleted(false)
     , size(size)
     , format(format)
     , type(Bitmap)
 {
 }
 
 CCResourceProvider::Child::Child()
 {
 }
 
@@ skipping 105 matching lines @@
     ASSERT(CCProxy::isImplThread());
     ResourceMap::iterator it = m_resources.find(id);
     CHECK(it != m_resources.end());
 #if WTF_NEW_HASHMAP_ITERATORS_INTERFACE
     Resource* resource = &it->value;
 #else
     Resource* resource = &it->second;
 #endif
     ASSERT(!resource->lockedForWrite);
     ASSERT(!resource->lockForReadCount);
-    ASSERT(!resource->markedForDeletion);
+    ASSERT(!resource->deleted);
 
     if (resource->exported) {
-        resource->markedForDeletion = true;
+        resource->deleted = true;
         return;
     } else
         deleteResourceInternal(it);
 }
 
 void CCResourceProvider::deleteResourceInternal(ResourceMap::iterator it)
 {
 #if WTF_NEW_HASHMAP_ITERATORS_INTERFACE
     Resource* resource = &it->value;
 #else
     Resource* resource = &it->second;
 #endif
     if (resource->glId && !resource->external) {
         WebGraphicsContext3D* context3d = m_context->context3D();
         ASSERT(context3d);
         GLC(context3d, context3d->deleteTexture(resource->glId));
     }
     if (resource->pixels)
         delete resource->pixels;
 
     m_resources.remove(it);
 }
 
 void CCResourceProvider::deleteOwnedResources(int pool)
 {
     ASSERT(CCProxy::isImplThread());
     ResourceIdArray toDelete;
     for (ResourceMap::iterator it = m_resources.begin(); it != m_resources.end(); ++it) {
 #if WTF_NEW_HASHMAP_ITERATORS_INTERFACE
-        if (it->value.pool == pool && !it->value.external && !it->value.markedForDeletion)
+        if (it->value.pool == pool && !it->value.external && !it->value.deleted)
             toDelete.append(it->key);
 #else
-        if (it->second.pool == pool && !it->second.external && !it->value.markedForDeletion)
+        if (it->second.pool == pool && !it->second.external && !it->value.deleted)
             toDelete.append(it->first);
 #endif
     }
     for (ResourceIdArray::iterator it = toDelete.begin(); it != toDelete.end(); ++it)
         deleteResource(*it);
 }
 
 CCResourceProvider::ResourceType CCResourceProvider::resourceType(ResourceId id)
 {
     ResourceMap::iterator it = m_resources.find(id);
@@ skipping 267 matching lines @@
     ASSERT(CCProxy::isImplThread());
     ChildMap::const_iterator it = m_children.find(child);
     ASSERT(it != m_children.end());
 #if WTF_NEW_HASHMAP_ITERATORS_INTERFACE
     return it->value.childToParentMap;
 #else
     return it->second.childToParentMap;
 #endif
 }
 
-CCResourceProvider::TransferableResourceList CCResourceProvider::prepareSendToParent(const ResourceIdArray& resources)
+void CCResourceProvider::prepareSendToParent(const ResourceIdArray& resources, TransferableResourceList* list)
 {
     ASSERT(CCProxy::isImplThread());
-    TransferableResourceList list;
-    list.syncPoint = 0;
+    list->sync_point = 0;
+    list->resources.clear();
     WebGraphicsContext3D* context3d = m_context->context3D();
     if (!context3d || !context3d->makeContextCurrent()) {
         // FIXME: Implement this path for software compositing.
-        return list;
+        return;
     }
     for (ResourceIdArray::const_iterator it = resources.begin(); it != resources.end(); ++it) {
         TransferableResource resource;
         if (transferResource(context3d, *it, &resource)) {
 #if WTF_NEW_HASHMAP_ITERATORS_INTERFACE
             m_resources.find(*it)->value.exported = true;
 #else
             m_resources.find(*it)->second.exported = true;
 #endif
-            list.resources.append(resource);
+            list->resources.push_back(resource);
         }
     }
-    if (list.resources.size())
-        list.syncPoint = context3d->insertSyncPoint();
-    return list;
+    if (list->resources.size())
+        list->sync_point = context3d->insertSyncPoint();
 }
 
-CCResourceProvider::TransferableResourceList CCResourceProvider::prepareSendToChild(int child, const ResourceIdArray& resources)
+void CCResourceProvider::prepareSendToChild(int child, const ResourceIdArray& resources, TransferableResourceList* list)
 {
     ASSERT(CCProxy::isImplThread());
-    TransferableResourceList list;
-    list.syncPoint = 0;
+    list->sync_point = 0;
+    list->resources.clear();
     WebGraphicsContext3D* context3d = m_context->context3D();
     if (!context3d || !context3d->makeContextCurrent()) {
         // FIXME: Implement this path for software compositing.
-        return list;
+        return;
     }
 #if WTF_NEW_HASHMAP_ITERATORS_INTERFACE
     Child& childInfo = m_children.find(child)->value;
 #else
     Child& childInfo = m_children.find(child)->second;
 #endif
     for (ResourceIdArray::const_iterator it = resources.begin(); it != resources.end(); ++it) {
         TransferableResource resource;
         if (!transferResource(context3d, *it, &resource))
             ASSERT_NOT_REACHED();
         resource.id = childInfo.parentToChildMap.get(*it);
         childInfo.parentToChildMap.remove(*it);
         childInfo.childToParentMap.remove(resource.id);
-        list.resources.append(resource);
+        list->resources.push_back(resource);
         deleteResource(*it);
     }
-    if (list.resources.size())
-        list.syncPoint = context3d->insertSyncPoint();
-    return list;
+    if (list->resources.size())
+        list->sync_point = context3d->insertSyncPoint();
 }
 
 void CCResourceProvider::receiveFromChild(int child, const TransferableResourceList& resources)
 {
     ASSERT(CCProxy::isImplThread());
     WebGraphicsContext3D* context3d = m_context->context3D();
     if (!context3d || !context3d->makeContextCurrent()) {
         // FIXME: Implement this path for software compositing.
         return;
     }
-    if (resources.syncPoint) {
+    if (resources.sync_point) {
         // NOTE: If the parent is a browser and the child a renderer, the parent
         // is not supposed to have its context wait, because that could induce
         // deadlocks and/or security issues. The caller is responsible for
-        // waiting asynchronously, and resetting syncPoint before calling this.
+        // waiting asynchronously, and resetting sync_point before calling this.
         // However if the parent is a renderer (e.g. browser tag), it may be ok
         // (and is simpler) to wait.
-        GLC(context3d, context3d->waitSyncPoint(resources.syncPoint));
+        GLC(context3d, context3d->waitSyncPoint(resources.sync_point));
     }
 #if WTF_NEW_HASHMAP_ITERATORS_INTERFACE
     Child& childInfo = m_children.find(child)->value;
 #else
     Child& childInfo = m_children.find(child)->second;
 #endif
-    for (Vector<TransferableResource>::const_iterator it = resources.resources.begin(); it != resources.resources.end(); ++it) {
+    for (std::vector<TransferableResource>::const_iterator it = resources.resources.begin(); it != resources.resources.end(); ++it) {
         unsigned textureId;
         GLC(context3d, textureId = context3d->createTexture());
         GLC(context3d, context3d->bindTexture(GraphicsContext3D::TEXTURE_2D, textureId));
         GLC(context3d, context3d->consumeTextureCHROMIUM(GraphicsContext3D::TEXTURE_2D, it->mailbox.name));
         ResourceId id = m_nextId++;
-        Resource resource(textureId, childInfo.pool, it->size, it->format);
+        Resource resource(textureId, childInfo.pool, IntSize(it->size.width(), it->size.height()), it->format);
         m_resources.add(id, resource);
         m_mailboxes.append(it->mailbox);
         childInfo.parentToChildMap.add(id, it->id);
         childInfo.childToParentMap.add(it->id, id);
     }
 }
 
 void CCResourceProvider::receiveFromParent(const TransferableResourceList& resources)
 {
     ASSERT(CCProxy::isImplThread());
     WebGraphicsContext3D* context3d = m_context->context3D();
     if (!context3d || !context3d->makeContextCurrent()) {
         // FIXME: Implement this path for software compositing.
         return;
     }
-    if (resources.syncPoint)
-        GLC(context3d, context3d->waitSyncPoint(resources.syncPoint));
-    for (Vector<TransferableResource>::const_iterator it = resources.resources.begin(); it != resources.resources.end(); ++it) {
+    if (resources.sync_point)
+        GLC(context3d, context3d->waitSyncPoint(resources.sync_point));
+    for (std::vector<TransferableResource>::const_iterator it = resources.resources.begin(); it != resources.resources.end(); ++it) {
         ResourceMap::iterator mapIterator = m_resources.find(it->id);
         ASSERT(mapIterator != m_resources.end());
 #if WTF_NEW_HASHMAP_ITERATORS_INTERFACE
         Resource* resource = &mapIterator->value;
 #else
         Resource* resource = &mapIterator->second;
 #endif
         ASSERT(resource->exported);
         resource->exported = false;
         GLC(context3d, context3d->bindTexture(GraphicsContext3D::TEXTURE_2D, resource->glId));
         GLC(context3d, context3d->consumeTextureCHROMIUM(GraphicsContext3D::TEXTURE_2D, it->mailbox.name));
         m_mailboxes.append(it->mailbox);
-        if (resource->markedForDeletion)
+        if (resource->deleted)
             deleteResourceInternal(mapIterator);
     }
 }
 
 bool CCResourceProvider::transferResource(WebGraphicsContext3D* context, ResourceId id, TransferableResource* resource)
 {
     ASSERT(CCProxy::isImplThread());
     ResourceMap::const_iterator it = m_resources.find(id);
     CHECK(it != m_resources.end());
 #if WTF_NEW_HASHMAP_ITERATORS_INTERFACE
     const Resource* source = &it->value;
 #else
     const Resource* source = &it->second;
 #endif
     ASSERT(!source->lockedForWrite);
     ASSERT(!source->lockForReadCount);
     ASSERT(!source->external);
     if (source->exported)
         return false;
     resource->id = id;
     resource->format = source->format;
-    resource->size = source->size;
+    resource->size = gfx::Size(source->size.height(), source->size.width());
     if (!m_mailboxes.isEmpty())
         resource->mailbox = m_mailboxes.takeFirst();
     else
         GLC(context, context->genMailboxCHROMIUM(resource->mailbox.name));
     GLC(context, context->bindTexture(GraphicsContext3D::TEXTURE_2D, source->glId));
     GLC(context, context->produceTextureCHROMIUM(GraphicsContext3D::TEXTURE_2D, resource->mailbox.name));
     return true;
 }
 
 void CCResourceProvider::trimMailboxDeque()
@@ skipping 28 matching lines @@
             if (childPoolSet.contains(it->second.pool))
 #endif
                 ++maxMailboxCount;
         }
     }
     while (m_mailboxes.size() > maxMailboxCount)
         m_mailboxes.removeFirst();
 }
 
 }