[DevTools] Migrate TargetObserver to AnimationModel observer where makes sense.

third_party/WebKit/Source/devtools/front_end/animation/AnimationModel.js

 // Copyright (c) 2014 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.
 
 /**
  * @unrestricted
  */
 Animation.AnimationModel = class extends SDK.SDKModel {
   /**
    * @param {!SDK.Target} target
    */
   constructor(target) {
     super(target);
+    this._runtimeModel = target.runtimeModel;
     this._agent = target.animationAgent();
     target.registerAnimationDispatcher(new Animation.AnimationDispatcher(this));
     /** @type {!Map.<string, !Animation.AnimationModel.Animation>} */
     this._animationsById = new Map();
     /** @type {!Map.<string, !Animation.AnimationModel.AnimationGroup>} */
     this._animationGroups = new Map();
     /** @type {!Array.<string>} */
     this._pendingAnimations = [];
     this._playbackRate = 1;
     var resourceTreeModel =
         /** @type {!SDK.ResourceTreeModel} */ (SDK.ResourceTreeModel.fromTarget(target));
     resourceTreeModel.addEventListener(SDK.ResourceTreeModel.Events.MainFrameNavigated, this._reset, this);
-    this._screenshotCapture = new Animation.AnimationModel.ScreenshotCapture(target, this, resourceTreeModel);
-  }
-
-  /**
-   * @param {!SDK.Target} target
-   * @return {?Animation.AnimationModel}
-   */
-  static fromTarget(target) {
-    return target.model(Animation.AnimationModel);
+    this._screenshotCapture =
+        new Animation.AnimationModel.ScreenshotCapture(this, target.pageAgent(), resourceTreeModel);
   }
 
   _reset() {
     this._animationsById.clear();
     this._animationGroups.clear();
     this._pendingAnimations = [];
     this.dispatchEventToListeners(Animation.AnimationModel.Events.ModelReset);
   }
 
   /**
    * @param {string} id
    */
   animationCreated(id) {
     this._pendingAnimations.push(id);
   }
 
   /**
    * @param {string} id
    */
   _animationCanceled(id) {
     this._pendingAnimations.remove(id);
     this._flushPendingAnimationsIfNeeded();
   }
 
   /**
    * @param {!Protocol.Animation.Animation} payload
    */
   animationStarted(payload) {
-    var animation = Animation.AnimationModel.Animation.parsePayload(this.target(), payload);
+    var animation = Animation.AnimationModel.Animation.parsePayload(this, payload);
 
     // Ignore Web Animations custom effects & groups.
     if (animation.type() === 'WebAnimation' && animation.source().keyframesRule().keyframes().length === 0) {
       this._pendingAnimations.remove(animation.id());
     } else {
       this._animationsById.set(animation.id(), animation);
       if (this._pendingAnimations.indexOf(animation.id()) === -1)
         this._pendingAnimations.push(animation.id());
     }
 
@@ skipping 75 matching lines @@
    */
   setPlaybackRate(playbackRate) {
     this._playbackRate = playbackRate;
     this._agent.setPlaybackRate(playbackRate);
   }
 
   /**
    * @param {!Array.<string>} animations
    */
   _releaseAnimations(animations) {
-    this.target().animationAgent().releaseAnimations(animations);
+    this._agent.releaseAnimations(animations);
   }
 
   /**
    * @override
    * @return {!Promise}
    */
   suspendModel() {
     this._reset();
     return this._agent.disable();
   }
@@ skipping 21 matching lines @@
 /** @enum {symbol} */
 Animation.AnimationModel.Events = {
   AnimationGroupStarted: Symbol('AnimationGroupStarted'),
   ModelReset: Symbol('ModelReset')
 };
 
 
 /**
  * @unrestricted
  */
-Animation.AnimationModel.Animation = class extends SDK.SDKObject {
+Animation.AnimationModel.Animation = class {
   /**
-   * @param {!SDK.Target} target
+   * @param {!Animation.AnimationModel} animationModel
    * @param {!Protocol.Animation.Animation} payload
    */
-  constructor(target, payload) {
-    super(target);
+  constructor(animationModel, payload) {
+    this._animationModel = animationModel;
     this._payload = payload;
-    this._source = new Animation.AnimationModel.AnimationEffect(this.target(), this._payload.source);
+    this._source = new Animation.AnimationModel.AnimationEffect(animationModel, this._payload.source);
   }
 
   /**
-   * @param {!SDK.Target} target
+   * @param {!Animation.AnimationModel} animationModel
    * @param {!Protocol.Animation.Animation} payload
    * @return {!Animation.AnimationModel.Animation}
    */
-  static parsePayload(target, payload) {
-    return new Animation.AnimationModel.Animation(target, payload);
+  static parsePayload(animationModel, payload) {
+    return new Animation.AnimationModel.Animation(animationModel, payload);
   }
 
   /**
    * @return {!Protocol.Animation.Animation}
    */
   payload() {
     return this._payload;
   }
 
   /**
@@ skipping 99 matching lines @@
   }
 
   /**
    * @param {number} duration
    * @param {number} delay
    */
   setTiming(duration, delay) {
     this._source.node().then(this._updateNodeStyle.bind(this, duration, delay));
     this._source._duration = duration;
     this._source._delay = delay;
-    this.target().animationAgent().setTiming(this.id(), duration, delay);
+    this._animationModel._agent.setTiming(this.id(), duration, delay);
   }
 
   /**
    * @param {number} duration
    * @param {number} delay
    * @param {!SDK.DOMNode} node
    */
   _updateNodeStyle(duration, delay, node) {
     var animationPrefix;
     if (this.type() === Animation.AnimationModel.Animation.Type.CSSTransition)
@@ skipping 14 matching lines @@
    * @return {!Promise.<?SDK.RemoteObject>}
    */
   remoteObjectPromise() {
     /**
      * @param {?Protocol.Error} error
      * @param {!Protocol.Runtime.RemoteObject} payload
      * @return {?SDK.RemoteObject}
      * @this {!Animation.AnimationModel.Animation}
      */
     function callback(error, payload) {
-      return !error ? this.target().runtimeModel.createRemoteObject(payload) : null;
+      return !error ? this._animationModel._runtimeModel.createRemoteObject(payload) : null;
     }
 
-    return this.target().animationAgent().resolveAnimation(this.id(), callback.bind(this));
+    return this._animationModel._agent.resolveAnimation(this.id(), callback.bind(this));
   }
 
   /**
    * @return {string}
    */
   _cssId() {
     return this._payload.cssId || '';
   }
 };
 
 
 /** @enum {string} */
 Animation.AnimationModel.Animation.Type = {
   CSSTransition: 'CSSTransition',
   CSSAnimation: 'CSSAnimation',
   WebAnimation: 'WebAnimation'
 };
 
 /**
  * @unrestricted
  */
-Animation.AnimationModel.AnimationEffect = class extends SDK.SDKObject {
+Animation.AnimationModel.AnimationEffect = class {
   /**
-   * @param {!SDK.Target} target
+   * @param {!Animation.AnimationModel} animationModel
    * @param {!Protocol.Animation.AnimationEffect} payload
    */
-  constructor(target, payload) {
-    super(target);
+  constructor(animationModel, payload) {
+    this._animationModel = animationModel;
     this._payload = payload;
     if (payload.keyframesRule)
-      this._keyframesRule = new Animation.AnimationModel.KeyframesRule(target, payload.keyframesRule);
+      this._keyframesRule = new Animation.AnimationModel.KeyframesRule(payload.keyframesRule);
     this._delay = this._payload.delay;
     this._duration = this._payload.duration;
   }
 
   /**
    * @return {number}
    */
   delay() {
     return this._delay;
   }
@@ skipping 41 matching lines @@
    */
   fill() {
     return this._payload.fill;
   }
 
   /**
    * @return {!Promise.<!SDK.DOMNode>}
    */
   node() {
     if (!this._deferredNode)
-      this._deferredNode = new SDK.DeferredDOMNode(this.target(), this.backendNodeId());
+      this._deferredNode = new SDK.DeferredDOMNode(this._animationModel.target(), this.backendNodeId());
     return this._deferredNode.resolvePromise();
   }
 
   /**
    * @return {!SDK.DeferredDOMNode}
    */
   deferredNode() {
-    return new SDK.DeferredDOMNode(this.target(), this.backendNodeId());
+    return new SDK.DeferredDOMNode(this._animationModel.target(), this.backendNodeId());
   }
 
   /**
    * @return {number}
    */
   backendNodeId() {
     return this._payload.backendNodeId;
   }
 
   /**
    * @return {?Animation.AnimationModel.KeyframesRule}
    */
   keyframesRule() {
     return this._keyframesRule;
   }
 
   /**
    * @return {string}
    */
   easing() {
     return this._payload.easing;
   }
 };
 
 /**
  * @unrestricted
  */
-Animation.AnimationModel.KeyframesRule = class extends SDK.SDKObject {
+Animation.AnimationModel.KeyframesRule = class {
   /**
-   * @param {!SDK.Target} target
    * @param {!Protocol.Animation.KeyframesRule} payload
    */
-  constructor(target, payload) {
-    super(target);
+  constructor(payload) {
     this._payload = payload;
     this._keyframes = this._payload.keyframes.map(function(keyframeStyle) {
-      return new Animation.AnimationModel.KeyframeStyle(target, keyframeStyle);
+      return new Animation.AnimationModel.KeyframeStyle(keyframeStyle);
     });
   }
 
   /**
    * @param {!Array.<!Protocol.Animation.KeyframeStyle>} payload
    */
   _setKeyframesPayload(payload) {
     this._keyframes = payload.map(function(keyframeStyle) {
-      return new Animation.AnimationModel.KeyframeStyle(this._target, keyframeStyle);
+      return new Animation.AnimationModel.KeyframeStyle(keyframeStyle);
     });
   }
 
   /**
    * @return {string|undefined}
    */
   name() {
     return this._payload.name;
   }
 
   /**
    * @return {!Array.<!Animation.AnimationModel.KeyframeStyle>}
    */
   keyframes() {
     return this._keyframes;
   }
 };
 
 /**
  * @unrestricted
  */
-Animation.AnimationModel.KeyframeStyle = class extends SDK.SDKObject {
+Animation.AnimationModel.KeyframeStyle = class {
   /**
-   * @param {!SDK.Target} target
    * @param {!Protocol.Animation.KeyframeStyle} payload
    */
-  constructor(target, payload) {
-    super(target);
+  constructor(payload) {
     this._payload = payload;
     this._offset = this._payload.offset;
   }
 
   /**
    * @return {string}
    */
   offset() {
     return this._offset;
   }
@@ skipping 16 matching lines @@
    * @return {string}
    */
   easing() {
     return this._payload.easing;
   }
 };
 
 /**
  * @unrestricted
  */
-Animation.AnimationModel.AnimationGroup = class extends SDK.SDKObject {
+Animation.AnimationModel.AnimationGroup = class {
   /**
-   * @param {!Animation.AnimationModel} model
+   * @param {!Animation.AnimationModel} animationModel
    * @param {string} id
    * @param {!Array.<!Animation.AnimationModel.Animation>} animations
    */
-  constructor(model, id, animations) {
-    super(model.target());
-    this._model = model;
+  constructor(animationModel, id, animations) {
+    this._animationModel = animationModel;
     this._id = id;
     this._animations = animations;
     this._paused = false;
     this._screenshots = [];
     this._screenshotImages = [];
   }
 
   /**
    * @return {string}
    */
   id() {
     return this._id;
   }
 
   /**
    * @return {!Array.<!Animation.AnimationModel.Animation>}
    */
   animations() {
     return this._animations;
   }
 
   release() {
-    this._model._animationGroups.remove(this.id());
-    this._model._releaseAnimations(this._animationIds());
+    this._animationModel._animationGroups.remove(this.id());
+    this._animationModel._releaseAnimations(this._animationIds());
   }
 
   /**
    * @return {!Array.<string>}
    */
   _animationIds() {
     /**
      * @param {!Animation.AnimationModel.Animation} animation
      * @return {string}
      */
@@ skipping 18 matching lines @@
     var maxDuration = 0;
     for (var i = 0; i < this._animations.length; ++i)
       maxDuration = Math.max(maxDuration, this._animations[i]._finiteDuration());
     return maxDuration;
   }
 
   /**
    * @param {number} currentTime
    */
   seekTo(currentTime) {
-    this.target().animationAgent().seekAnimations(this._animationIds(), currentTime);
+    this._animationModel._agent.seekAnimations(this._animationIds(), currentTime);
   }
 
   /**
    * @return {boolean}
    */
   paused() {
     return this._paused;
   }
 
   /**
    * @param {boolean} paused
    */
   togglePause(paused) {
     if (paused === this._paused)
       return;
     this._paused = paused;
-    this.target().animationAgent().setPaused(this._animationIds(), paused);
+    this._animationModel._agent.setPaused(this._animationIds(), paused);
   }
 
   /**
    * @return {!Promise.<number>}
    */
   currentTimePromise() {
     /**
      * @param {?Protocol.Error} error
      * @param {number} currentTime
      * @return {number}
      */
     function callback(error, currentTime) {
       return !error ? currentTime : 0;
     }
 
     var longestAnim = null;
     for (var anim of this._animations) {
       if (!longestAnim || anim.endTime() > longestAnim.endTime())
         longestAnim = anim;
     }
-    return this.target().animationAgent().getCurrentTime(longestAnim.id(), callback).catchException(0);
+    return this._animationModel._agent.getCurrentTime(longestAnim.id(), callback).catchException(0);
   }
 
   /**
    * @param {!Animation.AnimationModel.AnimationGroup} group
    * @return {boolean}
    */
   _matches(group) {
     /**
      * @param {!Animation.AnimationModel.Animation} anim
      * @return {string}
@@ skipping 13 matching lines @@
       if (left[i] !== right[i])
         return false;
     }
     return true;
   }
 
   /**
    * @param {!Animation.AnimationModel.AnimationGroup} group
    */
   _update(group) {
-    this._model._releaseAnimations(this._animationIds());
+    this._animationModel._releaseAnimations(this._animationIds());
     this._animations = group._animations;
   }
 
   /**
    * @return {!Array.<!Image>}
    */
   screenshots() {
     for (var i = 0; i < this._screenshots.length; ++i) {
       var image = new Image();
       image.src = 'data:image/jpeg;base64,' + this._screenshots[i];
@@ skipping 36 matching lines @@
   animationStarted(payload) {
     this._animationModel.animationStarted(payload);
   }
 };
 
 /**
  * @unrestricted
  */
 Animation.AnimationModel.ScreenshotCapture = class {
   /**
-   * @param {!SDK.Target} target
-   * @param {!Animation.AnimationModel} model
+   * @param {!Animation.AnimationModel} animationModel
+   * @param {!Protocol.PageAgent} pageAgent
    * @param {!SDK.ResourceTreeModel} resourceTreeModel
    */
-  constructor(target, model, resourceTreeModel) {
-    this._target = target;
+  constructor(animationModel, pageAgent, resourceTreeModel) {
     /** @type {!Array<!Animation.AnimationModel.ScreenshotCapture.Request>} */
     this._requests = [];
     resourceTreeModel.addEventListener(SDK.ResourceTreeModel.Events.ScreencastFrame, this._screencastFrame, this);
-    this._model = model;
-    this._model.addEventListener(Animation.AnimationModel.Events.ModelReset, this._stopScreencast, this);
+    this._pageAgent = pageAgent;
+    this._animationModel = animationModel;
+    this._animationModel.addEventListener(Animation.AnimationModel.Events.ModelReset, this._stopScreencast, this);
   }
 
   /**
    * @param {number} duration
    * @param {!Array<string>} screenshots
    */
   captureScreenshots(duration, screenshots) {
-    var screencastDuration = Math.min(duration / this._model._playbackRate, 3000);
+    var screencastDuration = Math.min(duration / this._animationModel._playbackRate, 3000);
     var endTime = screencastDuration + window.performance.now();
     this._requests.push({endTime: endTime, screenshots: screenshots});
 
     if (!this._endTime || endTime > this._endTime) {
       clearTimeout(this._stopTimer);
       this._stopTimer = setTimeout(this._stopScreencast.bind(this), screencastDuration);
       this._endTime = endTime;
     }
 
     if (this._capturing)
       return;
     this._capturing = true;
-    this._target.pageAgent().startScreencast('jpeg', 80, undefined, 300, 2);
+    this._pageAgent.startScreencast('jpeg', 80, undefined, 300, 2);
   }
 
   /**
    * @param {!Common.Event} event
    */
   _screencastFrame(event) {
     /**
      * @param {!Animation.AnimationModel.ScreenshotCapture.Request} request
      * @return {boolean}
      */
@@ skipping 12 matching lines @@
   }
 
   _stopScreencast() {
     if (!this._capturing)
       return;
 
     delete this._stopTimer;
     delete this._endTime;
     this._requests = [];
     this._capturing = false;
-    this._target.pageAgent().stopScreencast();
+    this._pageAgent.stopScreencast();
   }
 };
 
 /** @typedef {{ endTime: number, screenshots: !Array.<string>}} */
 Animation.AnimationModel.ScreenshotCapture.Request;