[DevTools] Separate ScreenCaptureModel out of ResourceTreeModel.

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(this, target.pageAgent(), resourceTreeModel);
+    var screenCaptureModel = target.model(SDK.ScreenCaptureModel);
+    if (screenCaptureModel)
+      this._screenshotCapture = new Animation.AnimationModel.ScreenshotCapture(this, screenCaptureModel);
   }
 
   _reset() {
     this._animationsById.clear();
     this._animationGroups.clear();
     this._pendingAnimations = [];
     this.dispatchEventToListeners(Animation.AnimationModel.Events.ModelReset);
   }
 
   /**
@@ skipping 48 matching lines @@
     for (var group of this._animationGroups.values()) {
       if (group._matches(incomingGroup)) {
         matchedGroup = group;
         group._update(incomingGroup);
         break;
       }
     }
 
     if (!matchedGroup) {
       this._animationGroups.set(incomingGroup.id(), incomingGroup);
-      this._screenshotCapture.captureScreenshots(incomingGroup.finiteDuration(), incomingGroup._screenshots);
+      if (this._screenshotCapture)
+        this._screenshotCapture.captureScreenshots(incomingGroup.finiteDuration(), incomingGroup._screenshots);
     }
     this.dispatchEventToListeners(Animation.AnimationModel.Events.AnimationGroupStarted, matchedGroup || incomingGroup);
     return !!matchedGroup;
   }
 
   /**
    * @return {!Animation.AnimationModel.AnimationGroup}
    */
   _createGroupFromPendingAnimations() {
     console.assert(this._pendingAnimations.length);
@@ skipping 660 matching lines @@
     this._animationModel.animationStarted(payload);
   }
 };
 
 /**
  * @unrestricted
  */
 Animation.AnimationModel.ScreenshotCapture = class {
   /**
    * @param {!Animation.AnimationModel} animationModel
-   * @param {!Protocol.PageAgent} pageAgent
-   * @param {!SDK.ResourceTreeModel} resourceTreeModel
+   * @param {!SDK.ScreenCaptureModel} screenCaptureModel
    */
-  constructor(animationModel, pageAgent, resourceTreeModel) {
+  constructor(animationModel, screenCaptureModel) {
     /** @type {!Array<!Animation.AnimationModel.ScreenshotCapture.Request>} */
     this._requests = [];
-    resourceTreeModel.addEventListener(SDK.ResourceTreeModel.Events.ScreencastFrame, this._screencastFrame, this);
-    this._pageAgent = pageAgent;
+    this._screenCaptureModel = screenCaptureModel;
     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._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._pageAgent.startScreencast('jpeg', 80, undefined, 300, 2);
+    this._screenCaptureModel.startScreencast(
+        'jpeg', 80, undefined, 300, 2, this._screencastFrame.bind(this), visible => {});
   }
 
   /**
-   * @param {!Common.Event} event
+   * @param {string} base64Data
+   * @param {!Protocol.Page.ScreencastFrameMetadata} metadata
    */
-  _screencastFrame(event) {
+  _screencastFrame(base64Data, metadata) {
     /**
      * @param {!Animation.AnimationModel.ScreenshotCapture.Request} request
      * @return {boolean}
      */
     function isAnimating(request) {
       return request.endTime >= now;
     }
 
     if (!this._capturing)
       return;
 
-    var base64Data = /** type {string} */ (event.data['data']);
     var now = window.performance.now();
     this._requests = this._requests.filter(isAnimating);
     for (var request of this._requests)
       request.screenshots.push(base64Data);
   }
 
   _stopScreencast() {
     if (!this._capturing)
       return;
 
     delete this._stopTimer;
     delete this._endTime;
     this._requests = [];
     this._capturing = false;
-    this._pageAgent.stopScreencast();
+    this._screenCaptureModel.stopScreencast();
   }
 };
 
 /** @typedef {{ endTime: number, screenshots: !Array.<string>}} */
 Animation.AnimationModel.ScreenshotCapture.Request;