ChangeLog

2012-08-01  James Robinson  <jamesr@chromium.org>

        [chromium] Move compositor HUD font atlas initialization code out of compositor core

        https://bugs.webkit.org/show_bug.cgi?id=92924

        Reviewed by NOBODY (OOPS!).

        The chromium compositor does not have any text rendering capabilities. It generally does not need them, but it

        is helpful for some debugging aids to be able to render at least ASCII text to the screen. This provides an API

        on WebLayerTreeView by which an embedder can provide an ASCII glyph atlas to use for displaying debug

        information.

        * chromium/public/WebLayerTreeView.h:

        (WebLayerTreeView):

2012-08-01  Tommy Widenflycht  <tommyw@google.com>

        MediaStream API: Add ExtraData capability to MediaStreamSource

Source/WebCore/ChangeLog

112012-08-01 James Robinson <jamesr@chromium.org>

22

        [chromium] Move compositor HUD font atlas initialization code out of compositor core

        https://bugs.webkit.org/show_bug.cgi?id=92924

        Reviewed by NOBODY (OOPS!).

        This moves the HUD font atlas initialization code out of the compositor implementation to cut out Font-related

        dependencies. The new flow is that an embedder can pass a font atlas to the CCLayerTreeHost, after which the

        atlas is provided the HUD layer (if any) on the next commit. The HUD layer renders text using the font atlas if

        it has any if the settings require text.

        HUD tested manually, we don't have automated tests for this debugging-only feature.

        * platform/graphics/chromium/CompositorHUDFontAtlas.cpp:

        (WebCore):

        (WebCore::CompositorHUDFontAtlas::generateFontAtlas):

        * platform/graphics/chromium/CompositorHUDFontAtlas.h:

        (CompositorHUDFontAtlas):

        * platform/graphics/chromium/HeadsUpDisplayLayerChromium.cpp:

        (WebCore::HeadsUpDisplayLayerChromium::create):

        (WebCore::HeadsUpDisplayLayerChromium::HeadsUpDisplayLayerChromium):

        (WebCore::HeadsUpDisplayLayerChromium::setFontAtlas):

        (WebCore):

        (WebCore::HeadsUpDisplayLayerChromium::createCCLayerImpl):

        (WebCore::HeadsUpDisplayLayerChromium::pushPropertiesTo):

        * platform/graphics/chromium/HeadsUpDisplayLayerChromium.h:

        (HeadsUpDisplayLayerChromium):

        * platform/graphics/chromium/cc/CCFontAtlas.cpp:

        (WebCore::CCFontAtlas::CCFontAtlas):

        * platform/graphics/chromium/cc/CCFontAtlas.h:

        (WebCore):

        (WebCore::CCFontAtlas::create):

        (CCFontAtlas):

        * platform/graphics/chromium/cc/CCHeadsUpDisplayLayerImpl.cpp:

        (WebCore::CCHeadsUpDisplayLayerImpl::CCHeadsUpDisplayLayerImpl):

        (WebCore::CCHeadsUpDisplayLayerImpl::setFontAtlas):

        (WebCore):

        * platform/graphics/chromium/cc/CCHeadsUpDisplayLayerImpl.h:

        (WebCore::CCHeadsUpDisplayLayerImpl::create):

        (CCHeadsUpDisplayLayerImpl):

        * platform/graphics/chromium/cc/CCLayerTreeHost.cpp:

        (WebCore::CCLayerTreeHost::setFontAtlas):

        (WebCore):

        (WebCore::CCLayerTreeHost::willCommit):

        * platform/graphics/chromium/cc/CCLayerTreeHost.h:

        (WebCore):

        (CCLayerTreeHost):

2012-08-01  James Robinson  <jamesr@chromium.org>

        [chromium] Move compositor HUD font atlas generation out of compositor core

        https://bugs.webkit.org/show_bug.cgi?id=92901

Source/WebKit/chromium/ChangeLog

2012-08-01  James Robinson  <jamesr@chromium.org>

        [chromium] Move compositor HUD font atlas initialization code out of compositor core

        https://bugs.webkit.org/show_bug.cgi?id=92924

        Reviewed by NOBODY (OOPS!).

        This initializes the compositor's font atlas when initialization the compositor if the "Show FPS counter" or

        "Show layer tree" settings are true.

        * src/WebLayerTreeView.cpp:

        (WebKit::WebLayerTreeView::setFontAtlas):

        (WebKit):

        * src/WebViewImpl.cpp:

        (WebKit::WebViewImpl::setIsAcceleratedCompositingActive):

2012-08-01  Peter Beverloo  <peter@chromium.org>

        [Text Autosizing] Provide an API for influencing the font scale factor

Source/Platform/chromium/public/WebLayerTreeView.h

#ifndef WebLayerTreeView_h

#define WebLayerTreeView_h

29#include "SkBitmap.h"

#include "WebColor.h"

#include "WebCommon.h"

#include "WebNonCopyable.h"

@@public:

    // This call is relatively expensive in threaded mode as it blocks on the compositor thread.

    WEBKIT_EXPORT void renderingStats(WebRenderingStats&) const;

    // Provides a font atlas to use for debug visualizations. The atlas must be a bitmap containing glyph data, a table of

    // ASCII character values to a subrectangle of the atlas representing the corresponding glyph, and the glyph height.

    WEBKIT_EXPORT void setFontAtlas(SkBitmap, WebRect asciiToRectTable[128], int fontHeight);

    // Simulates a lost context. For testing only.

    WEBKIT_EXPORT void loseCompositorContext(int numTimes);

Source/WebCore/platform/graphics/chromium/CompositorHUDFontAtlas.cpp

#include "TextRun.h"

#include "skia/ext/platform_canvas.h"

40using WebKit::WebRect;

41

namespace WebCore {

#define ATLAS_SIZE 128

@@static void wrapPositionIfNeeded(IntPoint& position, int textWidth, int textHeig

}

// Paints the font into the atlas, from left-to-right, top-to-bottom, starting at

51 // startingPosition. At the same time, it updates the ascii-to-~~Int~~Rect mapping for

53// startingPosition. At the same time, it updates the ascii-to-WebRect mapping for

5254// each character. By doing things this way, it is possible to support variable-width

5355// fonts and multiple fonts on the same atlas.

54 SkBitmap CompositorHUDFontAtlas::generateFontAtlas(~~Int~~Rect asciiToRectTable[128], int& fontHeight)

56SkBitmap CompositorHUDFontAtlas::generateFontAtlas(WebRect asciiToRectTable[128], int& fontHeight)

{

    fontHeight = 14;

@@SkBitmap CompositorHUDFontAtlas::generateFontAtlas(IntRect asciiToRectTable[128]

        atlasContext.strokeRect(FloatRect(FloatPoint(position.x() + 1, position.y() - textHeight + 1 + inflation), FloatSize(textWidth - 2, textHeight - 2 - inflation)), 1);

        // Initialize the rect that would be copied when drawing this glyph from the atlas.

94 asciiToRectTable[0] = ~~Int~~Rec~~t(IntPoin~~t(position.x(), position.y() - textHeight)~~, IntSize(~~textWidth, textHeight + inflation));

96 asciiToRectTable[0] = WebRect(position.x(), position.y() - textHeight, textWidth, textHeight + inflation);

        // Increment to the position where the next glyph will be placed.

        position.setX(position.x() + textWidth);

@@SkBitmap CompositorHUDFontAtlas::generateFontAtlas(IntRect asciiToRectTable[128]

        atlasContext.drawText(font, text, position);

        // Initialize the rect that would be copied when drawing this glyph from the atlas.

117 asciiToRectTable[i] = ~~Int~~Rec~~t(IntPoin~~t(position.x(), position.y() - textHeight)~~, IntSize(~~textWidth, textHeight + inflation));

119 asciiToRectTable[i] = WebRect(position.x(), position.y() - textHeight, textWidth, textHeight + inflation);

        // Increment to the position where the next glyph will be placed.

        position.setX(position.x() + textWidth);

Source/WebCore/platform/graphics/chromium/CompositorHUDFontAtlas.h

#ifndef CompositorHUDFontAtlas_h

#define CompositorHUDFontAtlas_h

29 #include "IntRect.h"

3029#include "SkBitmap.h"

30#include <public/WebRect.h>

namespace WebCore {

@@public:

    // This is a helper function that can generate a font atlas suitable for the compositor's heads up display.

    // Returns a bitmap containing glyphs and populates asciiToRectTable with the

    // location of each glyph.

39 static SkBitmap generateFontAtlas(IntRect asciiToRectTable[128], int& fontHeight);

39 static SkBitmap generateFontAtlas(WebKit::WebRect asciiToRectTable[128], int& fontHeight);

};

} // namespace WebCore

Source/WebCore/platform/graphics/chromium/HeadsUpDisplayLayerChromium.cpp

namespace WebCore {

36 PassRefPtr<HeadsUpDisplayLayerChromium> HeadsUpDisplayLayerChromium::create(~~const CCLayerTreeSettings& settings~~)

36PassRefPtr<HeadsUpDisplayLayerChromium> HeadsUpDisplayLayerChromium::create()

3737{

38 return adoptRef(new HeadsUpDisplayLayerChromium(~~settings~~));

38 return adoptRef(new HeadsUpDisplayLayerChromium());

3939}

4040

41 HeadsUpDisplayLayerChromium::HeadsUpDisplayLayerChromium(~~const CCLayerTreeSettings& settings~~)

41HeadsUpDisplayLayerChromium::HeadsUpDisplayLayerChromium()

    : LayerChromium()

{

    setBounds(IntSize(512, 128));

    // Only allocate the font atlas if we have reason to use the heads-up display.

    if (settings.showFPSCounter || settings.showPlatformLayerTree) {

        TRACE_EVENT0("cc", "HeadsUpDisplayLayerChromium::initializeFontAtlas");

        m_fontAtlas = CCFontAtlas::create();

        m_fontAtlas->initialize();

    }

}

HeadsUpDisplayLayerChromium::~HeadsUpDisplayLayerChromium()

@@void HeadsUpDisplayLayerChromium::update(CCTextureUpdater&, const CCOcclusionTra

    setBounds(bounds);

}

void HeadsUpDisplayLayerChromium::setFontAtlas(PassOwnPtr<CCFontAtlas> fontAtlas)

{

    m_fontAtlas = fontAtlas;

    setNeedsCommit();

}

7675PassOwnPtr<CCLayerImpl> HeadsUpDisplayLayerChromium::createCCLayerImpl()

7776{

78 return CCHeadsUpDisplayLayerImpl::create(m_layerId, m_fontAtlas.release());

    return CCHeadsUpDisplayLayerImpl::create(m_layerId);

}

void HeadsUpDisplayLayerChromium::pushPropertiesTo(CCLayerImpl* layerImpl)

{

    LayerChromium::pushPropertiesTo(layerImpl);

    if (!m_fontAtlas)

        return;

    CCHeadsUpDisplayLayerImpl* hudLayerImpl = static_cast<CCHeadsUpDisplayLayerImpl*>(layerImpl);

    hudLayerImpl->setFontAtlas(m_fontAtlas.release());

}

}

Source/WebCore/platform/graphics/chromium/HeadsUpDisplayLayerChromium.h

namespace WebCore {

36 struct CCLayerTreeSettings;

37

3836class HeadsUpDisplayLayerChromium : public LayerChromium {

3937public:

40 static PassRefPtr<HeadsUpDisplayLayerChromium> create(~~const CCLayerTreeSettings&~~);

38 static PassRefPtr<HeadsUpDisplayLayerChromium> create();

    virtual ~HeadsUpDisplayLayerChromium();

    virtual void update(CCTextureUpdater&, const CCOcclusionTracker*, CCRenderingStats&) OVERRIDE;

    virtual bool drawsContent() const OVERRIDE { return true; }

44 void setFontAtlas(PassOwnPtr<CCFontAtlas>);

45

4646 virtual PassOwnPtr<CCLayerImpl> createCCLayerImpl() OVERRIDE;

47 virtual void pushPropertiesTo(CCLayerImpl*) OVERRIDE;

4748

4849protected:

49 ~~explicit~~ HeadsUpDisplayLayerChromium(~~const CCLayerTreeSettings&~~);

50 HeadsUpDisplayLayerChromium();

private:

    OwnPtr<CCFontAtlas> m_fontAtlas;

Source/WebCore/platform/graphics/chromium/cc/CCFontAtlas.cpp

#if USE(ACCELERATED_COMPOSITING)

#include "CCFontAtlas.h"

30 #include "CompositorHUDFontAtlas.h"

#include "SkCanvas.h"

#include "cc/CCProxy.h"

@@namespace WebCore {

using namespace std;

CCFontAtlas::CCFontAtlas()

    : m_fontHeight(0)

CCFontAtlas::CCFontAtlas(SkBitmap bitmap, IntRect asciiToRectTable[128], int fontHeight)

    : m_atlas(bitmap)

    , m_fontHeight(fontHeight)

4140{

41 for (size_t i = 0; i < 128; ++i)

42 m_asciiToRectTable[i] = asciiToRectTable[i];

4243}

4344

44

CCFontAtlas::~CCFontAtlas()

{

}

void CCFontAtlas::initialize()

{

    ASSERT(CCProxy::isMainThread());

    m_atlas = CompositorHUDFontAtlas::generateFontAtlas(m_asciiToRectTable, m_fontHeight);

}

void CCFontAtlas::drawText(SkCanvas* canvas, const String& text, const IntPoint& destPosition, const IntSize& clip) const

{

    ASSERT(CCProxy::isImplThread());

Source/WebCore/platform/graphics/chromium/cc/CCFontAtlas.h

@@class IntPoint;

class IntSize;

// This class provides basic ability to draw text onto the heads-up display.

47 // It must be initialized on the main thread, and it can only draw text on the impl thread.

class CCFontAtlas {

    WTF_MAKE_NONCOPYABLE(CCFontAtlas);

public:

51 static PassOwnPtr<CCFontAtlas> create()

50 static PassOwnPtr<CCFontAtlas> create(SkBitmap bitmap, IntRect asciiToRectTable[128], int fontHeight)

5251 {

53 return adoptPtr(new CCFontAtlas());

52 return adoptPtr(new CCFontAtlas(bitmap, asciiToRectTable, fontHeight));

    }

    ~CCFontAtlas();

    // Creates the font atlas.

    // - Should only be called on the main thread.

    void initialize();

    // Draws multiple lines of text where each line of text is separated by '\n'.

    // - Correct glyphs will be drawn for ASCII codes in the range 32-127; any characters

    //   outside that range will be displayed as a default rectangle glyph.

@@public:

    void drawDebugAtlas(SkCanvas*, const IntPoint& destPosition) const;

private:

73 CCFontAtlas();

68 CCFontAtlas(SkBitmap, IntRect asciiToRectTable[128], int fontHeight);

    void drawOneLineOfTextInternal(SkCanvas*, const String&, const IntPoint& destPosition) const;

Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplayLayerImpl.cpp

@@using WebKit::WebCompositorTextureQuad;

namespace WebCore {

CCHeadsUpDisplayLayerImpl::CCHeadsUpDisplayLayerImpl(int id, PassOwnPtr<CCFontAtlas> fontAtlas)

    : CCLayerImpl(id),

      m_fontAtlas(fontAtlas)

48CCHeadsUpDisplayLayerImpl::CCHeadsUpDisplayLayerImpl(int id)

49 : CCLayerImpl(id)

{

}

@@CCHeadsUpDisplayLayerImpl::~CCHeadsUpDisplayLayerImpl()

{

}

void CCHeadsUpDisplayLayerImpl::setFontAtlas(PassOwnPtr<CCFontAtlas> fontAtlas)

{

    m_fontAtlas = fontAtlas;

}

void CCHeadsUpDisplayLayerImpl::willDraw(CCResourceProvider* resourceProvider)

{

    CCLayerImpl::willDraw(resourceProvider);

Source/WebCore/platform/graphics/chromium/cc/CCHeadsUpDisplayLayerImpl.h

@@class CCFrameRateCounter;

class CCHeadsUpDisplayLayerImpl : public CCLayerImpl {

public:

42 static PassOwnPtr<CCHeadsUpDisplayLayerImpl> create(int id~~, PassOwnPtr<CCFontAtlas> fontAtlas~~)

42 static PassOwnPtr<CCHeadsUpDisplayLayerImpl> create(int id)

4343 {

44 return adoptPtr(new CCHeadsUpDisplayLayerImpl(id~~, fontAtlas~~));

44 return adoptPtr(new CCHeadsUpDisplayLayerImpl(id));

    }

    virtual ~CCHeadsUpDisplayLayerImpl();

48 void setFontAtlas(PassOwnPtr<CCFontAtlas>);

49

    virtual void willDraw(CCResourceProvider*) OVERRIDE;

    virtual void appendQuads(CCQuadSink&, const CCSharedQuadState*, bool& hadMissingTiles) OVERRIDE;

    virtual void didDraw(CCResourceProvider*) OVERRIDE;

@@public:

    virtual bool layerIsAlwaysDamaged() const OVERRIDE { return true; }

private:

57 CCHeadsUpDisplayLayerImpl(int~~, PassOwnPtr<CCFontAtlas>~~);

59 explicit CCHeadsUpDisplayLayerImpl(int);

    virtual const char* layerTypeAsString() const OVERRIDE { return "HeadsUpDisplayLayer"; }

Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHost.cpp

#include "cc/CCLayerTreeHost.h"

29#include "CompositorHUDFontAtlas.h"

#include "HeadsUpDisplayLayerChromium.h"

#include "LayerChromium.h"

#include "Region.h"

@@void CCLayerTreeHost::finishCommitOnImplThread(CCLayerTreeHostImpl* hostImpl)

    m_commitNumber++;

}

void CCLayerTreeHost::setFontAtlas(PassOwnPtr<CCFontAtlas> fontAtlas)

{

    m_fontAtlas = fontAtlas;

    setNeedsCommit();

}

void CCLayerTreeHost::willCommit()

{

    m_client->willCommit();

    if (m_rootLayer && m_settings.showDebugInfo()) {

        if (!m_hudLayer)

259 m_hudLayer = HeadsUpDisplayLayerChromium::create(m_settings);

            m_hudLayer = HeadsUpDisplayLayerChromium::create();

        if (m_fontAtlas)

            m_hudLayer->setFontAtlas(m_fontAtlas.release());

        if (m_hudLayer->parent() != m_rootLayer.get()) {

            m_hudLayer->removeFromParent();

            m_rootLayer->addChild(m_hudLayer);

Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHost.h

namespace WebCore {

50class CCFontAtlas;

class CCGraphicsContext;

class CCLayerChromium;

class CCLayerTreeHostImpl;

class CCLayerTreeHostImplClient;

55class CCPrioritizedTextureManager;

5456class CCTextureUpdater;

57class HeadsUpDisplayLayerChromium;

5558class Region;

56 class CCPrioritizedTextureManager;

struct CCScrollAndScaleSet;

class CCLayerTreeHostClient {

@@public:

    void setDeviceScaleFactor(float);

    float deviceScaleFactor() const { return m_deviceScaleFactor; }

276 void setFontAtlas(PassOwnPtr<CCFontAtlas>);

277

protected:

    CCLayerTreeHost(CCLayerTreeHostClient*, const CCLayerTreeSettings&);

    bool initialize();

@@private:

    int m_numFailedRecreateAttempts;

    RefPtr<LayerChromium> m_rootLayer;

316 RefPtr<LayerChromium> m_hudLayer;

    RefPtr<HeadsUpDisplayLayerChromium> m_hudLayer;

    OwnPtr<CCFontAtlas> m_fontAtlas;

    OwnPtr<CCPrioritizedTextureManager> m_contentsTextureManager;

    OwnPtr<CCPrioritizedTexture> m_surfaceMemoryPlaceholder;

@@private:

    TextureList m_deleteTextureAfterCommitList;

    size_t m_partialTextureUpdateRequests;

346

    static bool s_needsFilterContext;

};

Source/WebKit/chromium/src/WebLayerTreeView.cpp

#include "GraphicsContext3DPrivate.h"

#include "LayerChromium.h"

#include "WebLayerTreeViewImpl.h"

32#include "cc/CCFontAtlas.h"

#include "cc/CCGraphicsContext.h"

#include "cc/CCLayerTreeHost.h"

#include "cc/CCRenderingStats.h"

@@void WebLayerTreeView::renderingStats(WebRenderingStats& stats) const

    stats.totalRasterizeTimeInSeconds = ccStats.totalRasterizeTimeInSeconds;

}

void WebLayerTreeView::setFontAtlas(SkBitmap bitmap, WebRect asciiToWebRectTable[128], int fontHeight)

{

    IntRect asciiToRectTable[128];

    for (int i = 0; i < 128; ++i)

        asciiToRectTable[i] = asciiToWebRectTable[i];

    OwnPtr<CCFontAtlas> fontAtlas = CCFontAtlas::create(bitmap, asciiToRectTable, fontHeight);

    m_private->layerTreeHost()->setFontAtlas(fontAtlas.release());

}

void WebLayerTreeView::loseCompositorContext(int numTimes)

{

    m_private->layerTreeHost()->loseContext(numTimes);

Source/WebKit/chromium/src/WebViewImpl.cpp

#include "Color.h"

#include "ColorSpace.h"

#include "CompositionUnderlineVectorBuilder.h"

45#include "CompositorHUDFontAtlas.h"

#include "ContextFeaturesClientImpl.h"

#include "ContextMenu.h"

#include "ContextMenuController.h"

@@void WebViewImpl::setIsAcceleratedCompositingActive(bool active)

            m_compositorCreationFailed = false;

            if (m_pageOverlays)

                m_pageOverlays->update();

            // Only allocate the font atlas if we have reason to use the heads-up display.

            if (layerTreeViewSettings.showFPSCounter || layerTreeViewSettings.showPlatformLayerTree) {

                TRACE_EVENT0("cc", "HeadsUpDisplayLayerChromium::initializeFontAtlas");

                WebRect asciiToRectTable[128];

                int fontHeight;

                SkBitmap bitmap = WebCore::CompositorHUDFontAtlas::generateFontAtlas(asciiToRectTable, fontHeight);

                m_layerTreeView.setFontAtlas(bitmap, asciiToRectTable, fontHeight);

            }

        } else {

            m_nonCompositedContentHost.clear();

            m_isAcceleratedCompositingActive = false;