void Home::appendCurrentTime()
{
setCurrentTime(currentTime() + 1);
}
void TimeService::timeout()
{
emit(currentTime(QDateTime::currentDateTime()));
}
void ScriptController::clearForClose()
{
double start = currentTime();
clearForClose(false);
blink::Platform::current()->histogramCustomCounts("WebCore.ScriptController.clearForClose", (currentTime() - start) * 1000, 0, 10000, 50);
}
void TextFinder::scopeStringMatches(int identifier,
const WebString& searchText,
const WebFindOptions& options) {
if (!shouldScopeMatches(searchText, options)) {
finishCurrentScopingEffort(identifier);
return;
}
PositionInFlatTree searchStart =
PositionInFlatTree::firstPositionInNode(ownerFrame().frame()->document());
PositionInFlatTree searchEnd =
PositionInFlatTree::lastPositionInNode(ownerFrame().frame()->document());
DCHECK_EQ(searchStart.document(), searchEnd.document());
if (m_resumeScopingFromRange) {
// This is a continuation of a scoping operation that timed out and didn't
// complete last time around, so we should start from where we left off.
DCHECK(m_resumeScopingFromRange->collapsed());
searchStart = fromPositionInDOMTree<EditingInFlatTreeStrategy>(
m_resumeScopingFromRange->endPosition());
if (searchStart.document() != searchEnd.document())
return;
}
// TODO(dglazkov): The use of updateStyleAndLayoutIgnorePendingStylesheets
// needs to be audited. see http://crbug.com/590369 for more details.
searchStart.document()->updateStyleAndLayoutIgnorePendingStylesheets();
// This timeout controls how long we scope before releasing control. This
// value does not prevent us from running for longer than this, but it is
// periodically checked to see if we have exceeded our allocated time.
const double maxScopingDuration = 0.1; // seconds
int matchCount = 0;
bool timedOut = false;
double startTime = currentTime();
do {
// Find next occurrence of the search string.
// FIXME: (http://crbug.com/6818) This WebKit operation may run for longer
// than the timeout value, and is not interruptible as it is currently
// written. We may need to rewrite it with interruptibility in mind, or
// find an alternative.
const EphemeralRangeInFlatTree result =
findPlainText(EphemeralRangeInFlatTree(searchStart, searchEnd),
searchText, options.matchCase ? 0 : CaseInsensitive);
if (result.isCollapsed()) {
// Not found.
break;
}
Range* resultRange = Range::create(
result.document(), toPositionInDOMTree(result.startPosition()),
toPositionInDOMTree(result.endPosition()));
if (resultRange->collapsed()) {
// resultRange will be collapsed if the matched text spans over multiple
// TreeScopes. FIXME: Show such matches to users.
searchStart = result.endPosition();
continue;
}
++matchCount;
// Catch a special case where Find found something but doesn't know what
// the bounding box for it is. In this case we set the first match we find
// as the active rect.
IntRect resultBounds = resultRange->boundingBox();
IntRect activeSelectionRect;
if (m_locatingActiveRect) {
activeSelectionRect =
m_activeMatch.get() ? m_activeMatch->boundingBox() : resultBounds;
}
// If the Find function found a match it will have stored where the
// match was found in m_activeSelectionRect on the current frame. If we
// find this rect during scoping it means we have found the active
// tickmark.
bool foundActiveMatch = false;
if (m_locatingActiveRect && (activeSelectionRect == resultBounds)) {
// We have found the active tickmark frame.
m_currentActiveMatchFrame = true;
foundActiveMatch = true;
// We also know which tickmark is active now.
m_activeMatchIndex = m_totalMatchCount + matchCount - 1;
// To stop looking for the active tickmark, we set this flag.
m_locatingActiveRect = false;
// Notify browser of new location for the selected rectangle.
reportFindInPageSelection(
ownerFrame().frameView()->contentsToRootFrame(resultBounds),
m_activeMatchIndex + 1, identifier);
}
ownerFrame().frame()->document()->markers().addTextMatchMarker(
EphemeralRange(resultRange), foundActiveMatch);
m_findMatchesCache.append(
FindMatch(resultRange, m_lastMatchCount + matchCount));
// Set the new start for the search range to be the end of the previous
// result range. There is no need to use a VisiblePosition here,
// since findPlainText will use a TextIterator to go over the visible
// text nodes.
searchStart = result.endPosition();
m_resumeScopingFromRange = Range::create(
result.document(), toPositionInDOMTree(result.endPosition()),
toPositionInDOMTree(result.endPosition()));
timedOut = (currentTime() - startTime) >= maxScopingDuration;
} while (!timedOut);
// Remember what we search for last time, so we can skip searching if more
// letters are added to the search string (and last outcome was 0).
m_lastSearchString = searchText;
if (matchCount > 0) {
ownerFrame().frame()->editor().setMarkedTextMatchesAreHighlighted(true);
m_lastMatchCount += matchCount;
// Let the frame know how many matches we found during this pass.
ownerFrame().increaseMatchCount(matchCount, identifier);
}
if (timedOut) {
// If we found anything during this pass, we should redraw. However, we
// don't want to spam too much if the page is extremely long, so if we
// reach a certain point we start throttling the redraw requests.
if (matchCount > 0)
invalidateIfNecessary();
// Scoping effort ran out of time, lets ask for another time-slice.
scopeStringMatchesSoon(identifier, searchText, options);
return; // Done for now, resume work later.
}
finishCurrentScopingEffort(identifier);
}
double RenderProgress::animationProgress() const
{
return m_animating ? (fmod((currentTime() - m_animationStartTime), m_animationDuration) / m_animationDuration) : 0;
}
void ScriptedAnimationController::animationTimerFired(Timer<ScriptedAnimationController>*)
{
m_lastAnimationFrameTime = currentTime();
serviceScriptedAnimations(convertSecondsToDOMTimeStamp(m_lastAnimationFrameTime));
}
void TextFinder::scopeStringMatches(int identifier, const WebString& searchText, const WebFindOptions& options, bool reset)
{
if (reset) {
// This is a brand new search, so we need to reset everything.
// Scoping is just about to begin.
m_scopingInProgress = true;
// Need to keep the current identifier locally in order to finish the
// request in case the frame is detached during the process.
m_findRequestIdentifier = identifier;
// Clear highlighting for this frame.
LocalFrame* frame = ownerFrame().frame();
if (frame && frame->page() && frame->editor().markedTextMatchesAreHighlighted())
frame->page()->unmarkAllTextMatches();
// Clear the tickmarks and results cache.
clearFindMatchesCache();
// Clear the counters from last operation.
m_lastMatchCount = 0;
m_nextInvalidateAfter = 0;
m_resumeScopingFromRange = nullptr;
// The view might be null on detached frames.
if (frame && frame->page())
ownerFrame().viewImpl()->mainFrameImpl()->ensureTextFinder().m_framesScopingCount++;
// Now, defer scoping until later to allow find operation to finish quickly.
scopeStringMatchesSoon(identifier, searchText, options, false); // false means just reset, so don't do it again.
return;
}
if (!shouldScopeMatches(searchText)) {
// Note that we want to defer the final update when resetting even if shouldScopeMatches returns false.
// This is done in order to prevent sending a final message based only on the results of the first frame
// since m_framesScopingCount would be 0 as other frames have yet to reset.
finishCurrentScopingEffort(identifier);
return;
}
WebLocalFrameImpl* mainFrameImpl = ownerFrame().viewImpl()->mainFrameImpl();
Position searchStart = firstPositionInNode(ownerFrame().frame()->document());
Position searchEnd = lastPositionInNode(ownerFrame().frame()->document());
ASSERT(searchStart.document() == searchEnd.document());
if (m_resumeScopingFromRange) {
// This is a continuation of a scoping operation that timed out and didn't
// complete last time around, so we should start from where we left off.
ASSERT(m_resumeScopingFromRange->collapsed());
searchStart = m_resumeScopingFromRange->endPosition();
if (searchStart.document() != searchEnd.document())
return;
}
// This timeout controls how long we scope before releasing control. This
// value does not prevent us from running for longer than this, but it is
// periodically checked to see if we have exceeded our allocated time.
const double maxScopingDuration = 0.1; // seconds
int matchCount = 0;
bool timedOut = false;
double startTime = currentTime();
do {
// Find next occurrence of the search string.
// FIXME: (http://crbug.com/6818) This WebKit operation may run for longer
// than the timeout value, and is not interruptible as it is currently
// written. We may need to rewrite it with interruptibility in mind, or
// find an alternative.
Position resultStart;
Position resultEnd;
findPlainText(searchStart, searchEnd, searchText, options.matchCase ? 0 : CaseInsensitive, resultStart, resultEnd);
if (resultStart == resultEnd) {
// Not found.
break;
}
RefPtrWillBeRawPtr<Range> resultRange = Range::create(*resultStart.document(), resultStart, resultEnd);
if (resultRange->collapsed()) {
// resultRange will be collapsed if the matched text spans over multiple TreeScopes.
// FIXME: Show such matches to users.
searchStart = resultEnd;
continue;
}
++matchCount;
// Catch a special case where Find found something but doesn't know what
// the bounding box for it is. In this case we set the first match we find
// as the active rect.
IntRect resultBounds = resultRange->boundingBox();
IntRect activeSelectionRect;
if (m_locatingActiveRect) {
activeSelectionRect = m_activeMatch.get() ?
m_activeMatch->boundingBox() : resultBounds;
}
// If the Find function found a match it will have stored where the
// match was found in m_activeSelectionRect on the current frame. If we
// find this rect during scoping it means we have found the active
// tickmark.
bool foundActiveMatch = false;
if (m_locatingActiveRect && (activeSelectionRect == resultBounds)) {
// We have found the active tickmark frame.
mainFrameImpl->ensureTextFinder().m_currentActiveMatchFrame = &ownerFrame();
foundActiveMatch = true;
// We also know which tickmark is active now.
m_activeMatchIndexInCurrentFrame = matchCount - 1;
// To stop looking for the active tickmark, we set this flag.
m_locatingActiveRect = false;
// Notify browser of new location for the selected rectangle.
reportFindInPageSelection(
ownerFrame().frameView()->contentsToWindow(resultBounds),
m_activeMatchIndexInCurrentFrame + 1,
identifier);
}
addMarker(resultRange.get(), foundActiveMatch);
m_findMatchesCache.append(FindMatch(resultRange.get(), m_lastMatchCount + matchCount));
// Set the new start for the search range to be the end of the previous
// result range. There is no need to use a VisiblePosition here,
// since findPlainText will use a TextIterator to go over the visible
// text nodes.
searchStart = resultEnd;
m_resumeScopingFromRange = Range::create(*resultStart.document(), resultEnd, resultEnd);
timedOut = (currentTime() - startTime) >= maxScopingDuration;
} while (!timedOut);
// Remember what we search for last time, so we can skip searching if more
// letters are added to the search string (and last outcome was 0).
m_lastSearchString = searchText;
if (matchCount > 0) {
ownerFrame().frame()->editor().setMarkedTextMatchesAreHighlighted(true);
m_lastMatchCount += matchCount;
// Let the mainframe know how much we found during this pass.
mainFrameImpl->increaseMatchCount(matchCount, identifier);
}
if (timedOut) {
// If we found anything during this pass, we should redraw. However, we
// don't want to spam too much if the page is extremely long, so if we
// reach a certain point we start throttling the redraw requests.
if (matchCount > 0)
invalidateIfNecessary();
// Scoping effort ran out of time, lets ask for another time-slice.
scopeStringMatchesSoon(
identifier,
searchText,
options,
false); // don't reset.
return; // Done for now, resume work later.
}
finishCurrentScopingEffort(identifier);
}
void InspectorResourceAgent::loadEventFired()
{
m_frontend->loadEventFired(currentTime());
}
void InspectorResourceAgent::didCloseWebSocket(unsigned long identifier)
{
m_frontend->webSocketClosed(static_cast<int>(identifier), currentTime());
}
void InspectorResourceAgent::didLoadResourceFromMemoryCache(DocumentLoader* loader, const CachedResource* resource)
{
m_frontend->resourceLoadedFromMemoryCache(pointerAsId(loader->frame()), pointerAsId(loader), loader->url().string(), currentTime(), buildObjectForCachedResource(*resource));
}
void InspectorResourceAgent::domContentEventFired()
{
m_frontend->domContentEventFired(currentTime());
}
void InspectorResourceAgent::didFailLoading(unsigned long identifier, const ResourceError& error)
{
m_frontend->loadingFailed(static_cast<int>(identifier), currentTime(), error.localizedDescription(), error.isCancellation());
}
void InspectorResourceAgent::didReceiveContentLength(unsigned long identifier, int dataLength, int encodedDataLength)
{
m_frontend->dataReceived(static_cast<int>(identifier), currentTime(), dataLength, encodedDataLength);
}
void InspectorResourceAgent::willSendRequest(unsigned long identifier, DocumentLoader* loader, ResourceRequest& request, const ResourceResponse& redirectResponse)
{
RefPtr<InspectorObject> headers = m_state->getObject(ResourceAgentState::extraRequestHeaders);
if (headers) {
InspectorObject::const_iterator end = headers->end();
for (InspectorObject::const_iterator it = headers->begin(); it != end; ++it) {
String value;
if (it->second->asString(&value))
request.setHTTPHeaderField(it->first, value);
}
}
request.setReportLoadTiming(true);
request.setReportRawHeaders(true);
RefPtr<ScriptCallStack> callStack = createScriptCallStack(ScriptCallStack::maxCallStackSizeToCapture, true);
RefPtr<InspectorArray> callStackValue;
if (callStack)
callStackValue = callStack->buildInspectorArray();
else
callStackValue = InspectorArray::create();
m_frontend->requestWillBeSent(static_cast<int>(identifier), pointerAsId(loader->frame()), pointerAsId(loader), loader->url().string(), buildObjectForResourceRequest(request), currentTime(), callStackValue, buildObjectForResourceResponse(redirectResponse));
}
SMILTime SMILTimeContainer::elapsed() const
{
if (!m_beginTime)
return 0;
return currentTime() - m_beginTime - m_accumulatedPauseTime;
}
SimulatedMouseEvent(const AtomicString& eventType, DOMWindow* view, RefPtr<Event>&& underlyingEvent, Element& target, SimulatedClickSource source)
: MouseEvent(eventType, true, true, underlyingEvent ? underlyingEvent->timeStamp() : currentTime(), view, 0, { }, { },
#if ENABLE(POINTER_LOCK)
{ },
#endif
false, false, false, false, 0, 0, 0, 0, 0, true)
{
if (source == SimulatedClickSource::Bindings)
setUntrusted();
if (UIEventWithKeyState* keyStateEvent = findEventWithKeyState(underlyingEvent.get())) {
m_ctrlKey = keyStateEvent->ctrlKey();
m_altKey = keyStateEvent->altKey();
m_shiftKey = keyStateEvent->shiftKey();
m_metaKey = keyStateEvent->metaKey();
}
setUnderlyingEvent(underlyingEvent.get());
if (is<MouseEvent>(this->underlyingEvent())) {
MouseEvent& mouseEvent = downcast<MouseEvent>(*this->underlyingEvent());
m_screenLocation = mouseEvent.screenLocation();
initCoordinates(mouseEvent.clientLocation());
} else if (source == SimulatedClickSource::UserAgent) {
// If there is no underlying event, we only populate the coordinates for events coming
// from the user agent (e.g. accessibility). For those coming from JavaScript (e.g.
// (element.click()), the coordinates will be 0, similarly to Firefox and Chrome.
// Note that the call to screenRect() causes a synchronous IPC with the UI process.
m_screenLocation = target.screenRect().center();
initCoordinates(LayoutPoint(target.clientRect().center()));
}
}
void TOSH_clock_set_interval(uint8_t interval) {
long long elapsed_time;
long long ticks;
int elapsedTicks;
int realInterval;
event_t* event = NULL;
interval = interval + 1;
dbg(DBG_CLOCK, "CLOCK: Setting clock interval to %u @ %s\n", (unsigned int)(interval & 0xff), currentTime());
if (clockEvents[NODE_NUM] != NULL) {
event_clocktick_invalidate(clockEvents[NODE_NUM]);
}
elapsed_time = tos_state.tos_time - setTime[NODE_NUM];
elapsedTicks = (elapsed_time / (long long)clockScales[scales[NODE_NUM]]);
realInterval = interval - elapsedTicks;
if (realInterval <= 0) {
realInterval += 256;
}
ticks = clockScales[(int)(scales[NODE_NUM] & 0xff)] * realInterval;
event = (event_t*)malloc(sizeof(event_t));
//dbg(DBG_MEM, "malloc clock tick event: 0x%x.\n", (int)event);
event_clocktick_create(event, NODE_NUM, tos_state.tos_time, ticks);
TOS_queue_insert_event(event);
intervals[NODE_NUM] = interval;
clockEvents[NODE_NUM] = event;
}
double TestRunner::preciseTime()
{
return currentTime();
}
void UtilitiesView::addWayPointTime(){
QTime currentTime(0,0,0,0);
currentTime = currentTime.addMSecs(lastTime);
ui->timeTable->setItem(currentLap, 3+lastWayPoint, new QTableWidgetItem(currentTime.toString("mm:ss:zzz")));
}
double InspectorTimelineAgent::currentTimeInMilliseconds()
{
return currentTime() * 1000.0;
}
double AnimationControllerPrivate::beginAnimationUpdateTime()
{
if (m_beginAnimationUpdateTime == cBeginAnimationUpdateTimeNotSet)
m_beginAnimationUpdateTime = currentTime();
return m_beginAnimationUpdateTime;
}
QTime QTime::currentTime()
{
QTime ct;
currentTime( &ct );
return ct;
}
void WebProcess::plugInDidStartFromOrigin(const String& pageOrigin, const String& pluginOrigin, const String& mimeType, SessionID sessionID)
{
if (pageOrigin.isEmpty()) {
LOG(Plugins, "Not adding empty page origin");
return;
}
unsigned plugInOriginHash = hashForPlugInOrigin(pageOrigin, pluginOrigin, mimeType);
if (isPlugInAutoStartOriginHash(plugInOriginHash, sessionID)) {
LOG(Plugins, "Hash %x already exists as auto-start origin (request for %s)", plugInOriginHash, pageOrigin.utf8().data());
return;
}
// We might attempt to start another plugin before the didAddPlugInAutoStartOrigin message
// comes back from the parent process. Temporarily add this hash to the list with a thirty
// second timeout. That way, even if the parent decides not to add it, we'll only be
// incorrect for a little while.
m_plugInAutoStartOriginHashes.add(sessionID, HashMap<unsigned, double>()).iterator->value.set(plugInOriginHash, currentTime() + 30 * 1000);
parentProcessConnection()->send(Messages::WebProcessPool::AddPlugInAutoStartOriginHash(pageOrigin, plugInOriginHash, sessionID), 0);
}
void QTime::start()
{
*this = currentTime();
}
void BitmapImage::startAnimation(bool catchUpIfNecessary)
{
if (m_frameTimer || !shouldAnimate() || frameCount() <= 1)
return;
// Determine time for next frame to start. By ignoring paint and timer lag
// in this calculation, we make the animation appear to run at its desired
// rate regardless of how fast it's being repainted.
const double currentDuration = frameDurationAtIndex(m_currentFrame);
const double time = currentTime();
if (m_desiredFrameStartTime == 0) {
m_desiredFrameStartTime = time + currentDuration;
} else {
m_desiredFrameStartTime += currentDuration;
// When an animated image is more than five minutes out of date, the
// user probably doesn't care about resyncing and we could burn a lot of
// time looping through frames below. Just reset the timings.
const double cAnimationResyncCutoff = 5 * 60;
if ((time - m_desiredFrameStartTime) > cAnimationResyncCutoff)
m_desiredFrameStartTime = time + currentDuration;
}
// Don't advance the animation to an incomplete frame.
size_t nextFrame = (m_currentFrame + 1) % frameCount();
if (!m_allDataReceived && !frameIsCompleteAtIndex(nextFrame))
return;
// Don't advance past the last frame if we haven't decoded the whole image
// yet and our repetition count is potentially unset. The repetition count
// in a GIF can potentially come after all the rest of the image data, so
// wait on it.
if (!m_allDataReceived && repetitionCount(false) == cAnimationLoopOnce && m_currentFrame >= (frameCount() - 1))
return;
// The image may load more slowly than it's supposed to animate, so that by
// the time we reach the end of the first repetition, we're well behind.
// Clamp the desired frame start time in this case, so that we don't skip
// frames (or whole iterations) trying to "catch up". This is a tradeoff:
// It guarantees users see the whole animation the second time through and
// don't miss any repetitions, and is closer to what other browsers do; on
// the other hand, it makes animations "less accurate" for pages that try to
// sync an image and some other resource (e.g. audio), especially if users
// switch tabs (and thus stop drawing the animation, which will pause it)
// during that initial loop, then switch back later.
if (nextFrame == 0 && m_repetitionsComplete == 0 && m_desiredFrameStartTime < time)
m_desiredFrameStartTime = time;
if (!catchUpIfNecessary || time < m_desiredFrameStartTime) {
// Haven't yet reached time for next frame to start; delay until then.
m_frameTimer = new Timer<BitmapImage>(this, &BitmapImage::advanceAnimation);
m_frameTimer->startOneShot(std::max(m_desiredFrameStartTime - time, 0.));
} else {
// We've already reached or passed the time for the next frame to start.
// See if we've also passed the time for frames after that to start, in
// case we need to skip some frames entirely. Remember not to advance
// to an incomplete frame.
for (size_t frameAfterNext = (nextFrame + 1) % frameCount(); frameIsCompleteAtIndex(frameAfterNext); frameAfterNext = (nextFrame + 1) % frameCount()) {
// Should we skip the next frame?
double frameAfterNextStartTime = m_desiredFrameStartTime + frameDurationAtIndex(nextFrame);
if (time < frameAfterNextStartTime)
break;
// Yes; skip over it without notifying our observers.
if (!internalAdvanceAnimation(true))
return;
m_desiredFrameStartTime = frameAfterNextStartTime;
nextFrame = frameAfterNext;
}
// Draw the next frame immediately. Note that m_desiredFrameStartTime
// may be in the past, meaning the next time through this function we'll
// kick off the next advancement sooner than this frame's duration would
// suggest.
if (internalAdvanceAnimation(false)) {
// The image region has been marked dirty, but once we return to our
// caller, draw() will clear it, and nothing will cause the
// animation to advance again. We need to start the timer for the
// next frame running, or the animation can hang. (Compare this
// with when advanceAnimation() is called, and the region is dirtied
// while draw() is not in the callstack, meaning draw() gets called
// to update the region and thus startAnimation() is reached again.)
// NOTE: For large images with slow or heavily-loaded systems,
// throwing away data as we go (see destroyDecodedData()) means we
// can spend so much time re-decoding data above that by the time we
// reach here we're behind again. If we let startAnimation() run
// the catch-up code again, we can get long delays without painting
// as we race the timer, or even infinite recursion. In this
// situation the best we can do is to simply change frames as fast
// as possible, so force startAnimation() to set a zero-delay timer
// and bail out if we're not caught up.
startAnimation(false);
}
}
}
void HTMLPlugInImageElement::subframeLoaderWillCreatePlugIn(const KURL& url)
{
if (!document()->page()
|| !document()->page()->settings()->plugInSnapshottingEnabled())
return;
bool inMainFrame = document()->frame() == document()->page()->mainFrame();
if (document()->isPluginDocument() && inMainFrame) {
LOG(Plugins, "%p Plug-in document in main frame", this);
return;
}
if (ScriptController::processingUserGesture()) {
LOG(Plugins, "%p Script is processing user gesture, set to play", this);
return;
}
if (m_createdDuringUserGesture) {
LOG(Plugins, "%p Plug-in was created when processing user gesture, set to play", this);
return;
}
double lastKnownUserGestureTimestamp = document()->lastHandledUserGestureTimestamp();
if (!inMainFrame && document()->page()->mainFrame() && document()->page()->mainFrame()->document())
lastKnownUserGestureTimestamp = std::max(lastKnownUserGestureTimestamp, document()->page()->mainFrame()->document()->lastHandledUserGestureTimestamp());
if (currentTime() - lastKnownUserGestureTimestamp < autostartSoonAfterUserGestureThreshold) {
LOG(Plugins, "%p Plug-in was created shortly after a user gesture, set to play", this);
return;
}
RenderBox* renderEmbeddedObject = toRenderBox(renderer());
Length styleWidth = renderEmbeddedObject->style()->width();
Length styleHeight = renderEmbeddedObject->style()->height();
LayoutRect contentBoxRect = renderEmbeddedObject->contentBoxRect();
int contentWidth = contentBoxRect.width();
int contentHeight = contentBoxRect.height();
int contentArea = contentWidth * contentHeight;
IntSize visibleViewSize = document()->frame()->view()->visibleSize();
int visibleArea = visibleViewSize.width() * visibleViewSize.height();
if (inMainFrame && styleWidth.isPercent() && (styleWidth.percent() == 100)
&& styleHeight.isPercent() && (styleHeight.percent() == 100)
&& (static_cast<float>(contentArea) / visibleArea > sizingFullPageAreaRatioThreshold)) {
LOG(Plugins, "%p Plug-in is top level full page, set to play", this);
return;
}
if (contentWidth <= sizingTinyDimensionThreshold || contentHeight <= sizingTinyDimensionThreshold) {
LOG(Plugins, "%p Plug-in is %dx%d, set to play", this, contentWidth, contentHeight);
return;
}
if (!document()->page() || !document()->page()->plugInClient()) {
setDisplayState(WaitingForSnapshot);
return;
}
LOG(Plugins, "%p Plug-in URL: %s", this, m_url.utf8().data());
LOG(Plugins, " loaded URL: %s", url.string().utf8().data());
m_plugInOriginHash = PlugInOriginHash::hash(this, url);
if (m_plugInOriginHash && document()->page()->plugInClient()->isAutoStartOrigin(m_plugInOriginHash)) {
LOG(Plugins, "%p Plug-in hash %x is auto-start, set to play", this, m_plugInOriginHash);
return;
}
LOG(Plugins, "%p Plug-in hash %x is %dx%d, origin is not auto-start, set to wait for snapshot", this, m_plugInOriginHash, contentWidth, contentHeight);
// We may have got to this point by restarting a snapshotted plug-in, in which case we don't want to
// reset the display state.
if (displayState() != PlayingWithPendingMouseClick)
setDisplayState(WaitingForSnapshot);
}
bool BitmapImage::dataChanged(bool allDataReceived)
{
// Because we're modifying the current frame, clear its (now possibly
// inaccurate) metadata as well.
#if !PLATFORM(IOS)
// Clear all partially-decoded frames. For most image formats, there is only
// one frame, but at least GIF and ICO can have more. With GIFs, the frames
// come in order and we ask to decode them in order, waiting to request a
// subsequent frame until the prior one is complete. Given that we clear
// incomplete frames here, this means there is at most one incomplete frame
// (even if we use destroyDecodedData() -- since it doesn't reset the
// metadata), and it is after all the complete frames.
//
// With ICOs, on the other hand, we may ask for arbitrary frames at
// different times (e.g. because we're displaying a higher-resolution image
// in the content area and using a lower-resolution one for the favicon),
// and the frames aren't even guaranteed to appear in the file in the same
// order as in the directory, so an arbitrary number of the frames might be
// incomplete (if we ask for frames for which we've not yet reached the
// start of the frame data), and any or none of them might be the particular
// frame affected by appending new data here. Thus we have to clear all the
// incomplete frames to be safe.
unsigned frameBytesCleared = 0;
for (size_t i = 0; i < m_frames.size(); ++i) {
// NOTE: Don't call frameIsCompleteAtIndex() here, that will try to
// decode any uncached (i.e. never-decoded or
// cleared-on-a-previous-pass) frames!
unsigned frameBytes = m_frames[i].m_frameBytes;
if (m_frames[i].m_haveMetadata && !m_frames[i].m_isComplete)
frameBytesCleared += (m_frames[i].clear(true) ? frameBytes : 0);
}
destroyMetadataAndNotify(frameBytesCleared, ClearedSource::No);
#else
// FIXME: why is this different for iOS?
int deltaBytes = 0;
if (!m_frames.isEmpty()) {
int bytes = m_frames[m_frames.size() - 1].m_frameBytes;
if (m_frames[m_frames.size() - 1].clear(true)) {
deltaBytes += bytes;
deltaBytes += m_decodedPropertiesSize;
m_decodedPropertiesSize = 0;
}
}
destroyMetadataAndNotify(deltaBytes, ClearedSource::No);
#endif
// Feed all the data we've seen so far to the image decoder.
m_allDataReceived = allDataReceived;
#if PLATFORM(IOS)
// FIXME: We should expose a setting to enable/disable progressive loading and make this
// code conditional on it. Then we can remove the PLATFORM(IOS)-guard.
static const double chunkLoadIntervals[] = {0, 1, 3, 6, 15};
double interval = chunkLoadIntervals[std::min(m_progressiveLoadChunkCount, static_cast<uint16_t>(4))];
bool needsUpdate = false;
if (currentTime() - m_progressiveLoadChunkTime > interval) { // The first time through, the chunk time will be 0 and the image will get an update.
needsUpdate = true;
m_progressiveLoadChunkTime = currentTime();
ASSERT(m_progressiveLoadChunkCount <= std::numeric_limits<uint16_t>::max());
++m_progressiveLoadChunkCount;
}
if (needsUpdate || allDataReceived)
m_source.setData(data(), allDataReceived);
#else
m_source.setData(data(), allDataReceived);
#endif
m_haveFrameCount = false;
m_source.setNeedsUpdateMetadata();
return isSizeAvailable();
}
void HTMLPlugInImageElement::subframeLoaderWillCreatePlugIn(const KURL& url)
{
LOG(Plugins, "%p Plug-in URL: %s", this, m_url.utf8().data());
LOG(Plugins, " Loaded URL: %s", url.string().utf8().data());
m_loadedUrl = url;
if (!document()->page()
|| !document()->page()->settings()->plugInSnapshottingEnabled())
return;
if (displayState() == Restarting) {
setDisplayState(Playing);
LOG(Plugins, "%p Plug-in is explicitly restarting", this);
return;
}
if (displayState() == RestartingWithPendingMouseClick) {
LOG(Plugins, "%p Plug-in is explicitly restarting but also waiting for a click", this);
return;
}
bool inMainFrame = document()->frame() == document()->page()->mainFrame();
if (document()->isPluginDocument() && inMainFrame) {
LOG(Plugins, "%p Plug-in document in main frame", this);
return;
}
if (ScriptController::processingUserGesture()) {
LOG(Plugins, "%p Script is currently processing user gesture, set to play", this);
return;
}
if (m_createdDuringUserGesture) {
LOG(Plugins, "%p Plug-in was created when processing user gesture, set to play", this);
return;
}
double lastKnownUserGestureTimestamp = document()->lastHandledUserGestureTimestamp();
if (!inMainFrame && document()->page()->mainFrame() && document()->page()->mainFrame()->document())
lastKnownUserGestureTimestamp = std::max(lastKnownUserGestureTimestamp, document()->page()->mainFrame()->document()->lastHandledUserGestureTimestamp());
if (currentTime() - lastKnownUserGestureTimestamp < autostartSoonAfterUserGestureThreshold) {
LOG(Plugins, "%p Plug-in was created shortly after a user gesture, set to play", this);
return;
}
if (document()->page()->settings()->snapshotAllPlugIns()) {
LOG(Plugins, "%p Plug-in forced to snapshot by user preference", this);
setDisplayState(WaitingForSnapshot);
return;
}
RenderBox* renderEmbeddedObject = toRenderBox(renderer());
Length styleWidth = renderEmbeddedObject->style()->width();
Length styleHeight = renderEmbeddedObject->style()->height();
LayoutRect contentBoxRect = renderEmbeddedObject->contentBoxRect();
int contentWidth = contentBoxRect.width();
int contentHeight = contentBoxRect.height();
int contentArea = contentWidth * contentHeight;
IntSize visibleViewSize = document()->frame()->view()->visibleSize();
int visibleArea = visibleViewSize.width() * visibleViewSize.height();
if (inMainFrame && styleWidth.isPercent() && (styleWidth.percent() == 100)
&& styleHeight.isPercent() && (styleHeight.percent() == 100)
&& (static_cast<float>(contentArea) / visibleArea > sizingFullPageAreaRatioThreshold)) {
LOG(Plugins, "%p Plug-in is top level full page, set to play", this);
return;
}
if (contentWidth <= sizingTinyDimensionThreshold || contentHeight <= sizingTinyDimensionThreshold) {
LOG(Plugins, "%p Plug-in is very small %dx%d, set to play", this, contentWidth, contentHeight);
return;
}
if (!document()->page()->plugInClient()) {
setDisplayState(WaitingForSnapshot);
return;
}
if (document()->page()->settings()->autostartOriginPlugInSnapshottingEnabled() && document()->page()->plugInClient()->shouldAutoStartFromOrigin(document()->page()->mainFrame()->document()->baseURL().host(), url.host(), loadedMimeType())) {
LOG(Plugins, "%p Plug-in from (%s, %s) is marked to auto-start, set to play", this, document()->page()->mainFrame()->document()->baseURL().host().utf8().data(), url.host().utf8().data());
return;
}
LOG(Plugins, "%p Plug-in from (%s, %s) is not auto-start, sized at %dx%d, set to wait for snapshot", this, document()->page()->mainFrame()->document()->baseURL().host().utf8().data(), url.host().utf8().data(), contentWidth, contentHeight);
setDisplayState(WaitingForSnapshot);
}
static PlatformMouseEvent createMouseEvent(DragData* dragData)
{
// FIXME: We should fake modifier keys here.
return PlatformMouseEvent(dragData->clientPosition(), dragData->globalPosition(),
LeftButton, MouseEventMoved, 0, false, false, false, false, currentTime());
}
void InspectorInputAgent::dispatchMouseEvent(ErrorString* error, const String& type, int x, int y, const int* modifiers, const double* timestamp, const String* button, const int* clickCount)
{
PlatformEvent::Type convertedType;
if (type == "mousePressed")
convertedType = PlatformEvent::MousePressed;
else if (type == "mouseReleased")
convertedType = PlatformEvent::MouseReleased;
else if (type == "mouseMoved")
convertedType = PlatformEvent::MouseMoved;
else {
*error = "Unrecognized type: " + type;
return;
}
int convertedModifiers = modifiers ? *modifiers : 0;
MouseButton convertedButton = NoButton;
if (button) {
if (*button == "left")
convertedButton = LeftButton;
else if (*button == "middle")
convertedButton = MiddleButton;
else if (*button == "right")
convertedButton = RightButton;
else if (*button != "none") {
*error = "Unrecognized button: " + *button;
return;
}
}
// Some platforms may have flipped coordinate systems, but the given coordinates
// assume the origin is in the top-left of the window. Convert.
IntPoint convertedPoint = m_page->mainFrame().view()->convertToContainingWindow(IntPoint(x, y));
IntPoint globalPoint = m_page->chrome().rootViewToScreen(IntRect(IntPoint(x, y), IntSize(0, 0))).location();
PlatformMouseEvent event(
convertedPoint,
globalPoint,
convertedButton,
convertedType,
clickCount ? *clickCount : 0,
convertedModifiers & PlatformEvent::ShiftKey,
convertedModifiers & PlatformEvent::CtrlKey,
convertedModifiers & PlatformEvent::AltKey,
convertedModifiers & PlatformEvent::MetaKey,
timestamp ? *timestamp : currentTime());
EventHandler& eventHandler = m_page->mainFrame().eventHandler();
switch (convertedType) {
case PlatformEvent::MousePressed:
eventHandler.handleMousePressEvent(event);
break;
case PlatformEvent::MouseReleased:
eventHandler.handleMouseReleaseEvent(event);
break;
case PlatformEvent::MouseMoved:
eventHandler.handleMouseMoveEvent(event);
break;
default:
*error = "Unhandled type: " + type;
}
}