Fix minimize -> fullscreen transition.

remoting/webapp/crd/js/fullscreen_v2.js

 // Copyright 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.
 
 /**
  * @fileoverview
  * Full-screen implementation for apps v2, using chrome.AppWindow.
  */
 
 'use strict';
 
 /** @suppress {duplicate} */
 var remoting = remoting || {};
 
 /**
  * @constructor
  * @implements {remoting.Fullscreen}
  */
 remoting.FullscreenAppsV2 = function() {
   /**
-   * @type {boolean} True if the next onRestored event should cause callbacks
-   *     to be notified of a full-screen changed event. onRestored fires when
-   *     full-screen mode is exited and also when the window is restored from
-   *     being minimized; callbacks should not be notified of the latter.
+   * @type {boolean} True if the window is minimized. onRestored fires when the
+   *     the window transitions from minimized to any other state, but since we
+   *     only want transitions from full-screen to windowed to cause a callback,
+   *     we must keep track of the minimized state of the window.
    * @private
    */
-  this.notifyCallbacksOnRestore_ = this.isActive();
+  this.isMinimized_ = chrome.app.window.current().isMinimized();
 
   /**
-   * @type {string} Internal 'full-screen changed' event name
+   * @type {?boolean} The most recent full-screen state passed to the callback.
+   *     This guards against redundant invocations, as as would otherwise occur
+   *     in response to a full-screen -> maximized -> unmaximized transition,
+   *     because this results in two onRestored callbacks.
+   */
+  this.previousCallbackState_ = null;

[kelvinp, 2015/01/23 18:26:07]

Nit: I think isFullScreen_ would be a better name. I don't feel strongly though.
 What do you think?

[Jamie, 2015/01/23 18:51:34]

I think there are a couple of options:

* Leave it as-is; maintaining the variable inside raiseEvent_ makes it very
clear what it does, and (I think) more obviously correct.
* Rename it to isFullscreen and maintain it in onFullscreened and onRestored;
this makes it nicely symmetric with isMinimized.

I prefer the first option (obviousness over symmetry), but in principle the
behaviour should be the same.

+
+  /**
+   * @type {string} Internal 'full-screen changed' event name.
    * @private
    */
   this.kEventName_ = '_fullscreenchanged';
 
   /**
    * @type {base.EventSource}
    * @private
    */
   this.eventSource_ = new base.EventSource();
   this.eventSource_.defineEvents([this.kEventName_]);
 
   chrome.app.window.current().onFullscreened.addListener(
       this.onFullscreened_.bind(this));
   chrome.app.window.current().onRestored.addListener(
       this.onRestored_.bind(this));
+  chrome.app.window.current().onMinimized.addListener(
+      this.onMinimized_.bind(this));
 };
 
+/**
+ * @param {boolean} fullscreen True to enter full-screen mode; false to leave.
+ * @param {function():void=} opt_onDone Optional completion callback.
+ */
 remoting.FullscreenAppsV2.prototype.activate = function(
     fullscreen, opt_onDone) {
   if (opt_onDone) {
     if (this.isActive() == fullscreen) {
       opt_onDone();
     } else {
       /** @type {remoting.Fullscreen} */
       var that = this;
       var callbackAndRemoveListener = function() {
         that.removeListener(callbackAndRemoveListener);
         opt_onDone();
       };
       this.addListener(callbackAndRemoveListener);
     }
   }
 
   if (fullscreen) {
     chrome.app.window.current().fullscreen();
   } else if (this.isActive()) {
     chrome.app.window.current().restore();
   }
 };
 
 remoting.FullscreenAppsV2.prototype.toggle = function() {
   this.activate(!this.isActive());
 };
 
+/**
+ * @return {boolean}
+ */
 remoting.FullscreenAppsV2.prototype.isActive = function() {
   return chrome.app.window.current().isFullscreen();
 };
 
 /**
  * @param {function(boolean=):void} callback
  */
 remoting.FullscreenAppsV2.prototype.addListener = function(callback) {
   this.eventSource_.addEventListener(this.kEventName_, callback);
 };
 
 /**
  * @param {function(boolean=):void} callback
  */
 remoting.FullscreenAppsV2.prototype.removeListener = function(callback) {
   this.eventSource_.removeEventListener(this.kEventName_, callback);
 };
 
+/**
+ * @private
+ */
 remoting.FullscreenAppsV2.prototype.onFullscreened_ = function() {
-  this.notifyCallbacksOnRestore_ = true;
-  this.eventSource_.raiseEvent(this.kEventName_, true);
+  this.isMinimized_ = false;
+  this.raiseEvent_(true);
   document.body.classList.add('fullscreen');
 };
 
+/**
+ * @private
+ */
 remoting.FullscreenAppsV2.prototype.onRestored_ = function() {
-  document.body.classList.remove('fullscreen');
-  if (this.notifyCallbacksOnRestore_) {
+  if (!this.isMinimized_) {
+    document.body.classList.remove('fullscreen');
     this.notifyCallbacksOnRestore_ = false;

[kelvinp, 2015/01/23 18:26:07]

Now this.notifyCallbacksOnRestore_ can be removed :)

[Jamie, 2015/01/23 18:51:34]

Done.

-    this.eventSource_.raiseEvent(this.kEventName_, false);
+    this.raiseEvent_(false);
+  }
+  this.isMinimized_ = false;
+};
+
+/**
+ * @private
+ */
+remoting.FullscreenAppsV2.prototype.onMinimized_ = function() {
+  this.isMinimized_ = true;
+};
+
+/**
+ * @param {boolean} isFullscreen
+ * @private
+ */
+remoting.FullscreenAppsV2.prototype.raiseEvent_ = function(isFullscreen) {
+  if (isFullscreen !== this.previousCallbackState_) {
+    this.previousCallbackState_ = isFullscreen;
+    this.eventSource_.raiseEvent(this.kEventName_, isFullscreen);
   }
 };