LOCAL_CFLAGS += -Darm -fvisibility=hidden
endif
-ifeq ($(WEBCORE_INSTRUMENTATION),true)
-LOCAL_CFLAGS += -DANDROID_INSTRUMENT
-endif
-
# LOCAL_LDLIBS is used in simulator builds only and simulator builds are only
# valid on Linux
LOCAL_LDLIBS += -lpthread -ldl
m_globalVarStorageOffset = -RegisterFile::CallFrameHeaderSize - m_codeBlock->numParameters - registerFile->size();
// Add previously defined symbols to bookkeeping.
- m_globals.grow(symbolTable->size());
+ m_globals.resize(symbolTable->size());
SymbolTable::iterator end = symbolTable->end();
for (SymbolTable::iterator it = symbolTable->begin(); it != end; ++it)
registerFor(it->second.getIndex()).setIndex(it->second.getIndex() + m_globalVarStorageOffset);
const Identifier* parameters = functionBody->parameters();
size_t parameterCount = functionBody->parameterCount();
m_nextParameter = -RegisterFile::CallFrameHeaderSize - parameterCount - 1;
- m_parameters.grow(1 + parameterCount); // reserve space for "this"
+ m_parameters.resize(1 + parameterCount); // reserve space for "this"
// Add "this" as a parameter
m_thisRegister.setIndex(m_nextParameter);
#include "RegisterFile.h"
#include <wtf/HashMap.h>
-#ifdef ANDROID_INSTRUMENT
-#include "TimeCounter.h"
-#endif
-
namespace JSC {
class CodeBlock;
{
if (!m_timeoutCheckCount)
resetTimeoutCheck();
-#ifdef ANDROID_INSTRUMENT
- if (!m_timeoutCheckCount)
- android::TimeCounter::start(android::TimeCounter::JavaScriptTimeCounter);
-#endif
+
++m_timeoutCheckCount;
}
{
ASSERT(m_timeoutCheckCount);
--m_timeoutCheckCount;
-#ifdef ANDROID_INSTRUMENT
- if (!m_timeoutCheckCount)
- android::TimeCounter::record(android::TimeCounter::JavaScriptTimeCounter, __FUNCTION__);
-#endif
}
inline void initTimeout()
namespace JSC {
- // SegmentedVector is just like Vector, but it doesn't move the values
- // stored in its buffer when it grows. Therefore, it is safe to keep
- // pointers into a SegmentedVector.
template <typename T, size_t SegmentSize> class SegmentedVector {
public:
SegmentedVector()
~SegmentedVector()
{
- deleteAllSegments();
- }
-
- size_t size() const { return m_size; }
-
- T& at(size_t index)
- {
- if (index < SegmentSize)
- return m_inlineSegment[index];
- return segmentFor(index)->at(subscriptFor(index));
- }
-
- T& operator[](size_t index)
- {
- return at(index);
+ for (size_t i = 1; i < m_segments.size(); i++)
+ delete m_segments[i];
}
T& last()
{
- return at(size() - 1);
+ ASSERT(m_size);
+ return m_segments.last()->last();
}
template <typename U> void append(const U& value)
{
- ++m_size;
-
- if (m_size <= SegmentSize) {
- m_inlineSegment.uncheckedAppend(value);
- return;
- }
-
- if (!segmentExistsFor(m_size - 1))
+ if (!(m_size % SegmentSize) && m_size)
m_segments.append(new Segment);
- segmentFor(m_size - 1)->uncheckedAppend(value);
+ m_segments.last()->uncheckedAppend(value);
+ m_size++;
}
void removeLast()
{
- if (m_size <= SegmentSize)
- m_inlineSegment.removeLast();
- else
- segmentFor(m_size - 1)->removeLast();
- --m_size;
+ ASSERT(m_size);
+ m_size--;
+ m_segments.last()->removeLast();
+ if (!(m_size % SegmentSize) && m_size >= SegmentSize) {
+ delete m_segments.last();
+ m_segments.removeLast();
+ }
}
- void grow(size_t size)
+ size_t size() const
{
- ASSERT(size > m_size);
- ensureSegmentsFor(size);
- m_size = size;
+ return m_size;
}
- void clear()
+ T& operator[](size_t index)
{
- deleteAllSegments();
- m_segments.resize(1);
- m_inlineSegment.clear();
- m_size = 0;
+ ASSERT(index < m_size);
+ if (index < SegmentSize)
+ return m_inlineSegment[index];
+ return m_segments[index / SegmentSize]->at(index % SegmentSize);
}
- private:
- typedef Vector<T, SegmentSize> Segment;
-
- void deleteAllSegments()
- {
- // Skip the first segment, because it's our inline segment, which was
- // not created by new.
- for (size_t i = 1; i < m_segments.size(); i++)
- delete m_segments[i];
- }
-
- bool segmentExistsFor(size_t index)
+ void resize(size_t size)
{
- return index / SegmentSize < m_segments.size();
+ if (size < m_size)
+ shrink(size);
+ else if (size > m_size)
+ grow(size);
+ ASSERT(size == m_size);
}
-
- Segment* segmentFor(size_t index)
- {
- return m_segments[index / SegmentSize];
- }
-
- size_t subscriptFor(size_t index)
- {
- return index % SegmentSize;
- }
-
- void ensureSegmentsFor(size_t size)
+
+ private:
+ void shrink(size_t size)
{
- size_t segmentCount = m_size / SegmentSize;
- if (m_size % SegmentSize)
- ++segmentCount;
- segmentCount = std::max<size_t>(segmentCount, 1); // We always have at least our inline segment.
-
- size_t neededSegmentCount = size / SegmentSize;
- if (size % SegmentSize)
- ++neededSegmentCount;
-
- // Fill up to N - 1 segments.
- size_t end = neededSegmentCount - 1;
- for (size_t i = segmentCount - 1; i < end; ++i)
- ensureSegment(i, SegmentSize);
-
- // Grow segment N to accomodate the remainder.
- ensureSegment(end, subscriptFor(size - 1) + 1);
+ ASSERT(size < m_size);
+ size_t numSegments = size / SegmentSize;
+ size_t extra = size % SegmentSize;
+ if (extra)
+ numSegments++;
+ if (!numSegments) {
+ for (size_t i = 1; i < m_segments.size(); i++)
+ delete m_segments[i];
+ m_segments.resize(1);
+ m_inlineSegment.resize(0);
+ return;
+ }
+
+ for (size_t i = numSegments; i < m_segments.size(); i++)
+ delete m_segments[i];
+
+ m_segments.resize(numSegments);
+ if (extra)
+ m_segments.last()->resize(extra);
+ m_size = size;
}
- void ensureSegment(size_t segmentIndex, size_t size)
+ void grow(size_t size)
{
- ASSERT(segmentIndex <= m_segments.size());
- if (segmentIndex == m_segments.size())
- m_segments.append(new Segment);
- m_segments[segmentIndex]->grow(size);
+ ASSERT(size > m_size);
+ if (size <= SegmentSize) {
+ m_inlineSegment.resize(size);
+ m_size = size;
+ return;
+ }
+
+ size_t numSegments = size / SegmentSize;
+ size_t extra = size % SegmentSize;
+ if (extra)
+ numSegments++;
+ size_t oldSize = m_segments.size();
+
+ if (numSegments == oldSize) {
+ m_segments.last()->resize(extra);
+ m_size = size;
+ return;
+ }
+
+ m_segments.last()->resize(SegmentSize);
+
+ m_segments.resize(numSegments);
+
+ ASSERT(oldSize < m_segments.size());
+ for (size_t i = oldSize; i < (numSegments - 1); i++) {
+ Segment* segment = new Segment;
+ segment->resize(SegmentSize);
+ m_segments[i] = segment;
+ }
+
+ Segment* segment = new Segment;
+ segment->resize(extra ? extra : SegmentSize);
+ m_segments[numSegments - 1] = segment;
+ m_size = size;
}
+ typedef Vector<T, SegmentSize> Segment;
size_t m_size;
Segment m_inlineSegment;
Vector<Segment*, 32> m_segments;
#if PLATFORM(ANDROID)
#define ANDROID_MOBILE // change can be merged back to WebKit.org for MOBILE
+//#define ANDROID_INSTRUMENT
#endif
#if PLATFORM(WIN_OS)
#define ANDROID_SELECT_TEXT_AREAS
#define ANDROID_FIX
+// note: if uncomment ANDROID_INSTRUMENT here, you must also
+// uncomment it on line 31 of JavaScriptCore/kjs/config.h
+// #define ANDROID_INSTRUMENT
// Fix for issue 878095. Only call onBlur on an element if it has an
// onBlur event.
#include "PluginInfoStore.h"
#include "KURL.h"
-#if PLATFORM(ANDROID)
-#include "Page.h"
-#endif
#include "PluginData.h"
#include "PluginDatabase.h"
#include "PluginPackage.h"
void refreshPlugins(bool reloadOpenPages)
{
-#if PLATFORM(ANDROID)
- Page::refreshPlugins(reloadOpenPages);
-#else
PluginDatabase::installedPlugins()->refresh();
if (reloadOpenPages) {
// FIXME: reload open pages
}
-#endif
}
}
uint32_t TimeCounter::sStartTime[TimeCounter::TotalTimeCounterCount];
static const char* timeCounterNames[] = {
- "css parsing",
- "javascript",
"calculate style",
+ "css parsing",
"Java callback (frame bridge)",
- "parsing (may include calcStyle or Java callback)",
"layout",
"native 1 (frame bridge)",
- "native 2 (resource load)",
- "native 3 (shared timer)",
+ "parsing (may include calcStyle or Java callback)",
+ "native 3 (resource load)",
+ "native 2 (shared timer)",
"build nav (webview core)",
+ "draw content (webview core)",
"record content (webview core)",
- "native 4 (webview core)",
- "draw content (webview ui)",
+ "native 4 (webview core)"
};
void TimeCounter::record(enum Type type, const char* functionName)
int threadTime = get_thread_msec() - sStartThreadTime;
LOGD("*-* Total load time: %d ms, thread time: %d ms for %s\n",
totalTime, threadTime, urlString.utf8().data());
+// FIXME: JSGlobalObject no longer records time
+// JSC::JSGlobalObject::reportTimeCounter();
for (Type type = (Type) 0; type < TotalTimeCounterCount; type
= (Type) (type + 1)) {
char scratch[256];
LOGD("*-* Elapsed time: %d ms, ui thread time: %d ms, webcore thread time:"
" %d ms\n", elapsedTime, elapsedThreadTime, sEndWebCoreThreadTime -
sStartWebCoreThreadTime);
+// FIXME: JSGlobalObject no longer records time
+// JSC::JSGlobalObject::reportTimeCounter();
for (Type type = (Type) 0; type < TotalTimeCounterCount; type
= (Type) (type + 1)) {
if (sTotalTimeUsed[type] == sLastTimeUsed[type])
}
void TimeCounter::reset() {
+// FIXME: JSGlobalObject no longer records time
+// JSC::JSGlobalObject::resetTimeCounter();
bzero(sTotalTimeUsed, sizeof(sTotalTimeUsed));
bzero(sCounter, sizeof(sCounter));
LOGD("*-* Start browser instrument\n");
class TimeCounter {
public:
enum Type {
- // function base counters
- CSSTimeCounter,
- JavaScriptTimeCounter,
CalculateStyleTimeCounter,
+ CSSTimeCounter,
JavaCallbackTimeCounter,
- ParsingTimeCounter,
LayoutTimeCounter,
- // file base counters
- NativeCallbackTimeCounter, // WebCoreFrameBridge.cpp
- ResourceTimeCounter, // WebCoreResourceLoader.cpp
- SharedTimerTimeCounter, // JavaBridge.cpp
+ NativeCallbackTimeCounter,
+ ParsingTimeCounter,
+ ResourceTimeCounter,
+ SharedTimerTimeCounter,
WebViewCoreBuildNavTimeCounter,
+ WebViewCoreDrawTimeCounter,
WebViewCoreRecordTimeCounter,
- WebViewCoreTimeCounter, // WebViewCore.cpp
- WebViewUIDrawTimeCounter,
+ WebViewCoreTimeCounter,
TotalTimeCounterCount
};
pluginDatabase->setPluginDirectories(paths);
// Set the home directory for plugin temporary files
WebCore::sPluginPath = paths[0];
- // Reload plugins. We call Page::refreshPlugins() instead
- // of pluginDatabase->refresh(), as we need to ensure that
- // the list of mimetypes exposed by the browser are also
- // updated.
- WebCore::Page::refreshPlugins(false);
+ // Reload plugins.
+ pluginDatabase->refresh();
}
}
#endif
bool WebViewCore::drawContent(SkCanvas* canvas, SkColor color)
{
#ifdef ANDROID_INSTRUMENT
- TimeCounterAuto counter(TimeCounter::WebViewUIDrawTimeCounter);
+ TimeCounterAuto counter(TimeCounter::WebViewCoreDrawTimeCounter);
#endif
DBG_SET_LOG("start");
m_contentMutex.lock();
bool WebViewCore::finalKitFocus(WebCore::Frame* frame, WebCore::Node* node,
int x, int y, bool donotChangeDOMFocus)
{
- CacheBuilder& builder = FrameLoaderClientAndroid::
- get(m_mainFrame)->getCacheBuilder();
- if (!frame || builder.validNode(frame, NULL) == false)
+ if (!frame)
frame = m_mainFrame;
+ CacheBuilder& builder = FrameLoaderClientAndroid::get(m_mainFrame)->getCacheBuilder();
WebCore::Node* oldFocusNode = builder.currentFocus();
// mouse event expects the position in the window coordinate
m_mousePos = WebCore::IntPoint(x - m_scrollOffsetX, y - m_scrollOffsetY);
// validNode will still return true if the node is null, as long as we have
// a valid frame. Do not want to make a call on frame unless it is valid.
- WebCore::PlatformMouseEvent mouseEvent(m_mousePos, m_mousePos,
- WebCore::NoButton, WebCore::MouseEventMoved, 1, false, false, false,
- false, WebCore::currentTime());
- frame->eventHandler()->handleMouseMoveEvent(mouseEvent);
bool valid = builder.validNode(frame, node);
+ if (valid) {
+ WebCore::PlatformMouseEvent mouseEvent(m_mousePos, m_mousePos, WebCore::NoButton,
+ WebCore::MouseEventMoved, 1, false, false, false, false, WebCore::currentTime());
+ frame->eventHandler()->handleMouseMoveEvent(mouseEvent);
+ }
+
if (!donotChangeDOMFocus) {
WebCore::Document* oldDoc = oldFocusNode ? oldFocusNode->document() : 0;
if (!node) {
" x=%d y=%d", m_touchGeneration, touchGeneration, x, y);
return; // short circuit if a newer touch has been generated
}
- if (retry || isClick)
+ if (retry)
finalKitFocus(frame, node, x, y, true); // don't change DOM focus
else if (!commonKitFocus(touchGeneration, buildGeneration,
frame, node, x, y, false)) {
static void SetGlobalBounds(JNIEnv *env, jobject obj, jint x, jint y, jint h,
jint v)
{
-#ifdef ANDROID_INSTRUMENT
- TimeCounterAuto counter(TimeCounter::WebViewCoreTimeCounter);
-#endif
WebViewCore* viewImpl = GET_NATIVE_VIEW(env, obj);
LOG_ASSERT(viewImpl, "need viewImpl");
static void SplitContent(JNIEnv *env, jobject obj)
{
-#ifdef ANDROID_INSTRUMENT
- TimeCounterAuto counter(TimeCounter::WebViewCoreTimeCounter);
-#endif
WebViewCore* viewImpl = GET_NATIVE_VIEW(env, obj);
viewImpl->splitContent();
}
static jstring FindAddress(JNIEnv *env, jobject obj, jstring addr)
{
-#ifdef ANDROID_INSTRUMENT
- TimeCounterAuto counter(TimeCounter::WebViewCoreTimeCounter);
-#endif
if (!addr)
return 0;
int length = env->GetStringLength(addr);
static jboolean HandleTouchEvent(JNIEnv *env, jobject obj, jint action, jint x, jint y)
{
-#ifdef ANDROID_INSTRUMENT
- TimeCounterAuto counter(TimeCounter::WebViewCoreTimeCounter);
-#endif
WebViewCore* viewImpl = GET_NATIVE_VIEW(env, obj);
LOG_ASSERT(viewImpl, "viewImpl not set in %s", __FUNCTION__);
return viewImpl->handleTouchEvent(action, x, y);
static jstring RetrieveHref(JNIEnv *env, jobject obj, jint frame,
jint node)
{
-#ifdef ANDROID_INSTRUMENT
- TimeCounterAuto counter(TimeCounter::WebViewCoreTimeCounter);
-#endif
WebViewCore* viewImpl = GET_NATIVE_VIEW(env, obj);
LOG_ASSERT(viewImpl, "viewImpl not set in %s", __FUNCTION__);
WebCore::String result = viewImpl->retrieveHref((WebCore::Frame*) frame,
static void UnblockFocus(JNIEnv *env, jobject obj)
{
-#ifdef ANDROID_INSTRUMENT
- TimeCounterAuto counter(TimeCounter::WebViewCoreTimeCounter);
-#endif
WebViewCore* viewImpl = GET_NATIVE_VIEW(env, obj);
LOG_ASSERT(viewImpl, "viewImpl not set in %s", __FUNCTION__);
viewImpl->unblockFocus();
static void UpdateFrameCache(JNIEnv *env, jobject obj)
{
-#ifdef ANDROID_INSTRUMENT
- TimeCounterAuto counter(TimeCounter::WebViewCoreTimeCounter);
-#endif
WebViewCore* viewImpl = GET_NATIVE_VIEW(env, obj);
LOG_ASSERT(viewImpl, "viewImpl not set in %s", __FUNCTION__);
viewImpl->updateFrameCache();
static jint GetContentMinPrefWidth(JNIEnv *env, jobject obj)
{
-#ifdef ANDROID_INSTRUMENT
- TimeCounterAuto counter(TimeCounter::WebViewCoreTimeCounter);
-#endif
WebViewCore* viewImpl = GET_NATIVE_VIEW(env, obj);
LOG_ASSERT(viewImpl, "viewImpl not set in %s", __FUNCTION__);
static void SetViewportSettingsFromNative(JNIEnv *env, jobject obj)
{
-#ifdef ANDROID_INSTRUMENT
- TimeCounterAuto counter(TimeCounter::WebViewCoreTimeCounter);
-#endif
WebViewCore* viewImpl = GET_NATIVE_VIEW(env, obj);
LOG_ASSERT(viewImpl, "viewImpl not set in %s", __FUNCTION__);
static void SetSnapAnchor(JNIEnv *env, jobject obj, jint x, jint y)
{
-#ifdef ANDROID_INSTRUMENT
- TimeCounterAuto counter(TimeCounter::WebViewCoreTimeCounter);
-#endif
WebViewCore* viewImpl = GET_NATIVE_VIEW(env, obj);
LOG_ASSERT(viewImpl, "viewImpl not set in %s", __FUNCTION__);
static void SnapToAnchor(JNIEnv *env, jobject obj)
{
-#ifdef ANDROID_INSTRUMENT
- TimeCounterAuto counter(TimeCounter::WebViewCoreTimeCounter);
-#endif
WebViewCore* viewImpl = GET_NATIVE_VIEW(env, obj);
LOG_ASSERT(viewImpl, "viewImpl not set in %s", __FUNCTION__);
static void SetBackgroundColor(JNIEnv *env, jobject obj, jint color)
{
-#ifdef ANDROID_INSTRUMENT
- TimeCounterAuto counter(TimeCounter::WebViewCoreTimeCounter);
-#endif
WebViewCore* viewImpl = GET_NATIVE_VIEW(env, obj);
LOG_ASSERT(viewImpl, "viewImpl not set in %s", __FUNCTION__);
static jstring GetSelection(JNIEnv *env, jobject obj, jobject selRgn)
{
-#ifdef ANDROID_INSTRUMENT
- TimeCounterAuto counter(TimeCounter::WebViewCoreTimeCounter);
-#endif
WebViewCore* viewImpl = GET_NATIVE_VIEW(env, obj);
LOG_ASSERT(viewImpl, "viewImpl not set in %s", __FUNCTION__);
SkRegion* selectionRegion = GraphicsJNI::getNativeRegion(env, selRgn);
jobject obj,
jboolean reloadOpenPages)
{
-#ifdef ANDROID_INSTRUMENT
- TimeCounterAuto counter(TimeCounter::WebViewCoreTimeCounter);
-#endif
// Refresh the list of plugins, optionally reloading all open
// pages.
WebCore::refreshPlugins(reloadOpenPages);
}
static void RegisterURLSchemeAsLocal(JNIEnv* env, jobject obj, jstring scheme) {
-#ifdef ANDROID_INSTRUMENT
- TimeCounterAuto counter(TimeCounter::WebViewCoreTimeCounter);
-#endif
WebCore::FrameLoader::registerURLSchemeAsLocal(to_string(env, scheme));
}
static void CheckNavCache(JNIEnv *env, jobject obj)
{
-#ifdef ANDROID_INSTRUMENT
- TimeCounterAuto counter(TimeCounter::WebViewCoreTimeCounter);
-#endif
WebViewCore* viewImpl = GET_NATIVE_VIEW(env, obj);
viewImpl->checkNavCache();
}
static void ClearContent(JNIEnv *env, jobject obj)
{
-#ifdef ANDROID_INSTRUMENT
- TimeCounterAuto counter(TimeCounter::WebViewCoreTimeCounter);
-#endif
WebViewCore* viewImpl = GET_NATIVE_VIEW(env, obj);
viewImpl->clearContent();
}
static void CopyContentToPicture(JNIEnv *env, jobject obj, jobject pict)
{
-#ifdef ANDROID_INSTRUMENT
- TimeCounterAuto counter(TimeCounter::WebViewCoreTimeCounter);
-#endif
WebViewCore* viewImpl = GET_NATIVE_VIEW(env, obj);
if (!viewImpl)
return;
static bool DrawContent(JNIEnv *env, jobject obj, jobject canv, jint color)
{
- // Note: this is called from UI thread, don't count it for WebViewCoreTimeCounter
WebViewCore* viewImpl = GET_NATIVE_VIEW(env, obj);
SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, canv);
return viewImpl->drawContent(canvas, color);
IntRect bounds;
IntRect absBounds;
WTF::Vector<IntRect>* columns = NULL;
- int minimumFocusableWidth = MINIMUM_FOCUSABLE_WIDTH;
- int minimumFocusableHeight = MINIMUM_FOCUSABLE_HEIGHT;
if (isArea) {
HTMLAreaElement* area = static_cast<HTMLAreaElement*>(node);
bounds = getAreaRect(area);
style->textAlign() == WebCore::RIGHT ||
style->textAlign() == WebCore::WEBKIT_RIGHT;
}
- minimumFocusableWidth += 4;
- minimumFocusableHeight += 4;
}
takesFocus = true;
if (isAnchor) {
bounds.setLocation(IntPoint(x, y));
bounds.setSize(IntSize(width, height));
}
- if (bounds.width() < minimumFocusableWidth)
+ if (bounds.width() < MINIMUM_FOCUSABLE_WIDTH)
continue;
- if (bounds.height() < minimumFocusableHeight)
+ if (bounds.height() < MINIMUM_FOCUSABLE_HEIGHT)
continue;
bounds.move(globalOffsetX, globalOffsetY);
}
if (mWorkingIndex) {
SkPoint newY;
getTotalMatrix().mapXY(0, y, &newY);
- SkIRect workingBounds = mWorkingRegion.getBounds();
- int newYInt = SkScalarRound(newY.fY);
- if (workingBounds.fTop > newYInt) {
- // The new text is above the working region, so we know it's not
- // a continuation.
- resetWorkingCanvas();
- mWorkingIndex = 0;
- mWorkingRegion.setEmpty();
- } else if (workingBounds.fBottom < newYInt) {
+ SkIRect bounds = mWorkingRegion.getBounds();
+ if (bounds.fBottom < SkScalarRound(newY.fY)) {
// Now we know that this line is lower than our partial match.
SkPaint clonePaint(paint);
clonePaint.setTextEncoding(SkPaint::kUTF8_TextEncoding);
mWorkingRegion.setEmpty();
}
}
- // If neither one is true, then we are likely continuing on the same
- // line, but are in a new draw call because the paint has changed. In
- // this case, we can continue without adding a space.
}
// j is the position in the search text
// Start off with mWorkingIndex in case we are continuing from a prior call
// call.
// Keep track of a partial match that may start on this line.
if (j > 0) { // if j is greater than 0, we have a partial match
- int relativeCount = j - mWorkingIndex; // Number of characters in this
- // part of the match.
- int partialIndex = index - relativeCount; // Index that starts our
- // partial match.
+ int partialIndex = index - j + mWorkingIndex;
const uint16_t* partialGlyphs = chars + partialIndex;
- SkRect partial = (this->*addMatch)(partialIndex, paint, relativeCount,
+ SkRect partial = (this->*addMatch)(partialIndex, paint, j,
partialGlyphs, positions, y);
partial.inset(mOutset, mOutset);
+ getTotalMatrix().mapRect(&partial);
SkIRect dest;
partial.roundOut(&dest);
// Only save a partial if it is in the current clip.
if (getTotalClip().contains(dest)) {
mWorkingRegion.op(dest, SkRegion::kUnion_Op);
mWorkingIndex = j;
+ // From one perspective, it seems like we would want to draw here,
+ // since we have all the information (paint, matrix, etc)
+ // However, we only want to draw if we find the rest
return;
}
}
OSDN Git Service
