blink: Rename modules/ method to prefix with get when they collide.

third_party/WebKit/Source/core/animation/Animation.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 595 matching lines @@
     setCurrentTimeInternal(newCurrentTime, TimingUpdateOnDemand);
     m_paused = false;
     m_currentTimePending = false;
     m_startTime = calculateStartTime(newCurrentTime);
     m_playState = Finished;
 }
 
 ScriptPromise Animation::finished(ScriptState* scriptState)
 {
     if (!m_finishedPromise) {
-        m_finishedPromise = new AnimationPromise(scriptState->executionContext(), this, AnimationPromise::Finished);
+        m_finishedPromise = new AnimationPromise(scriptState->getExecutionContext(), this, AnimationPromise::Finished);
         if (playStateInternal() == Finished)
             m_finishedPromise->resolve(this);
     }
     return m_finishedPromise->promise(scriptState->world());
 }
 
 ScriptPromise Animation::ready(ScriptState* scriptState)
 {
     if (!m_readyPromise) {
-        m_readyPromise = new AnimationPromise(scriptState->executionContext(), this, AnimationPromise::Ready);
+        m_readyPromise = new AnimationPromise(scriptState->getExecutionContext(), this, AnimationPromise::Ready);
         if (playStateInternal() != Pending)
             m_readyPromise->resolve(this);
     }
     return m_readyPromise->promise(scriptState->world());
 }
 
 const AtomicString& Animation::interfaceName() const
 {
     return EventTargetNames::AnimationPlayer;
 }
 
-ExecutionContext* Animation::executionContext() const
+ExecutionContext* Animation::getExecutionContext() const
 {
-    return ContextLifecycleObserver::executionContext();
+    return ContextLifecycleObserver::getExecutionContext();
 }
 
 bool Animation::hasPendingActivity() const
 {
     return m_pendingFinishedEvent || (!m_finished && hasEventListeners(EventTypeNames::finish));
 }
 
 void Animation::contextDestroyed()
 {
     PlayStateUpdateScope updateScope(*this, TimingUpdateOnDemand);
@@ skipping 173 matching lines @@
         // Special case for end-exclusivity when playing backwards.
         if (inheritedTime == 0 && m_playbackRate < 0)
             inheritedTime = -1;
         m_content->updateInheritedTime(inheritedTime, reason);
     }
 
     if ((idle || limited()) && !m_finished) {
         if (reason == TimingUpdateForAnimationFrame && (idle || hasStartTime())) {
             if (idle) {
                 const AtomicString& eventType = EventTypeNames::cancel;
-                if (executionContext() && hasEventListeners(eventType)) {
+                if (getExecutionContext() && hasEventListeners(eventType)) {
                     double eventCurrentTime = nullValue();
                     m_pendingCancelledEvent = AnimationPlayerEvent::create(eventType, eventCurrentTime, timeline()->currentTime());
                     m_pendingCancelledEvent->setTarget(this);
                     m_pendingCancelledEvent->setCurrentTarget(this);
                     m_timeline->document()->enqueueAnimationFrameEvent(m_pendingCancelledEvent);
                 }
             } else {
                 const AtomicString& eventType = EventTypeNames::finish;
-                if (executionContext() && hasEventListeners(eventType)) {
+                if (getExecutionContext() && hasEventListeners(eventType)) {
                     double eventCurrentTime = currentTimeInternal() * 1000;
                     m_pendingFinishedEvent = AnimationPlayerEvent::create(eventType, eventCurrentTime, timeline()->currentTime());
                     m_pendingFinishedEvent->setTarget(this);
                     m_pendingFinishedEvent->setCurrentTarget(this);
                     m_timeline->document()->enqueueAnimationFrameEvent(m_pendingFinishedEvent);
                 }
             }
             m_finished = true;
         }
     }
@@ skipping 191 matching lines @@
     }
     m_animation->endUpdatingState();
 
     if (oldPlayState != newPlayState)
         InspectorInstrumentation::animationPlayStateChanged(m_animation->timeline()->document(), m_animation, oldPlayState, newPlayState);
 }
 
 bool Animation::addEventListenerInternal(const AtomicString& eventType, PassRefPtrWillBeRawPtr<EventListener> listener, const EventListenerOptions& options)
 {
     if (eventType == EventTypeNames::finish)
-        UseCounter::count(executionContext(), UseCounter::AnimationFinishEvent);
+        UseCounter::count(getExecutionContext(), UseCounter::AnimationFinishEvent);
     return EventTargetWithInlineData::addEventListenerInternal(eventType, listener, options);
 }
 
 void Animation::pauseForTesting(double pauseTime)
 {
     RELEASE_ASSERT(!paused());
     setCurrentTimeInternal(pauseTime, TimingUpdateOnDemand);
     if (hasActiveAnimationsOnCompositor())
         toKeyframeEffect(m_content.get())->pauseAnimationForTestingOnCompositor(currentTimeInternal());
     m_isPausedForTesting = true;
@@ skipping 12 matching lines @@
     visitor->trace(m_timeline);
     visitor->trace(m_pendingFinishedEvent);
     visitor->trace(m_pendingCancelledEvent);
     visitor->trace(m_finishedPromise);
     visitor->trace(m_readyPromise);
     RefCountedGarbageCollectedEventTargetWithInlineData<Animation>::trace(visitor);
     ContextLifecycleObserver::trace(visitor);
 }
 
 } // namespace blink