Hotword: Make the new extension work with the NTP opt-in promo.

chrome/browser/resources/hotword/page_audio_manager.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.
 
 cr.define('hotword', function() {
   'use strict';
 
   /**
    * Class used to manage the interaction between hotwording and the
    * NTP/google.com. Injects a content script to interact with NTP/google.com
@@ skipping 18 matching lines @@
 
     /**
      * Chrome event listeners. Saved so that they can be de-registered when
      * hotwording is disabled.
      */
     this.connectListener_ = this.handleConnect_.bind(this);
     this.tabCreatedListener_ = this.handleCreatedTab_.bind(this);
     this.tabUpdatedListener_ = this.handleUpdatedTab_.bind(this);
     this.tabActivatedListener_ = this.handleActivatedTab_.bind(this);
     this.windowFocusChangedListener_ = this.handleChangedWindow_.bind(this);
+    this.messageListener_ = this.handleMessageFromPage_.bind(this);
 
     // Need to setup listeners on startup, otherwise events that caused the
     // event page to start up, will be lost.
     this.setupListeners_();
 
     this.stateManager_.onStatusChanged.addListener(function() {
       this.updateListeners_();
+      this.updateTabState_();
     }.bind(this));
   };
 
   var CommandToPage = hotword.constants.CommandToPage;
   var CommandFromPage = hotword.constants.CommandFromPage;
 
   PageAudioManager.prototype = {
     /**
      * Helper function to test if a URL path is eligible for hotwording.
      * @param {!string} url URL to check.
@@ skipping 45 matching lines @@
         'de',
         'es',
         'fr',
         'it',
         'ru'
       ];
 
       // Check for the new tab page first.
       if (this.checkUrlPathIsEligible_(url, 'chrome://newtab'))
         return true;
+      if (this.checkUrlPathIsEligible_(url, 'http://kcarattini-z620.syd.corp.google.com:8888/'))

[Anand Mistry (off Chromium), 2015/03/10 02:47:29]

Remove.

[kcarattini, 2015/03/10 04:34:05]

Done.

+        return true;
 
       // Check URLs with each type of local-based TLD.
       for (var i = 0; i < baseGoogleUrls.length; i++) {
         for (var j = 0; j < tlds.length; j++) {
           var base = baseGoogleUrls[i] + tlds[j];
           if (this.checkUrlPathIsEligible_(url, base))
             return true;
         }
       }
       return false;
@@ skipping 99 matching lines @@
     handleUpdatedTab_: function(tabId, info, tab) {
       // Chrome fires multiple update events: undefined, loading and completed.
       // We perform content injection on loading state.
       if (info['status'] != 'loading')
         return;
 
       this.prepareTab_(tab);
     },
 
     /**
-     * Handles a tab that was just became active.
+     * Handles a tab that has just become active.
      * @param {{tabId: number}} info Information about the activated tab.
      * @private
      */
     handleActivatedTab_: function(info) {
       this.updateTabState_();
     },
 
 
     /**
      * Handles a change in Chrome windows.
@@ skipping 100 matching lines @@
       this.stateManager_.startSession(
           hotword.constants.SessionSource.NTP,
           function() {
             this.sendAllClients_(CommandToPage.HOTWORD_STARTED);
           }.bind(this),
           this.hotwordTriggered_.bind(this));
     },
 
     /**
      * Starts hotwording if the currently active tab is eligible for hotwording
-     * (i.e. google.com).
+     * (e.g. google.com).
      * @private
      */
     startHotwordingIfEligible_: function() {
       this.findCurrentTab_(function(tab) {
         if (!tab) {
           this.stopHotwording_();
           return;
         }
         if (this.isEligibleUrl_(tab.url))
           this.startHotwording_();
@@ skipping 39 matching lines @@
         case CommandFromPage.SPEECH_START:
           this.stopHotwording_();
           break;
         case CommandFromPage.SPEECH_END:
         case CommandFromPage.SPEECH_RESET:
           this.startHotwording_();
           break;
       }
     },
 
+
+    /**
+     * Handles a message directly from the NTP/HP/SERP.
+     * @param {!Object} request Message from the sender.
+     * @param {!MessageSender} sender Information about the sender.
+     * @param {!function(HotwordStatus)} sendResponse Callback to respond
+     *     to sender.
+     * @return {boolean} Whether to maintain the port open to call sendResponse.
+     * @private
+     */
+    handleMessageFromPage_: function(request, sender, sendResponse) {
+      switch (request.type) {
+        case CommandFromPage.PAGE_WAKEUP:
+          if ((sender.tab && this.isEligibleUrl_(sender.tab.url)) &&
+              chrome.hotwordPrivate && chrome.hotwordPrivate.getStatus) {

[Anand Mistry (off Chromium), 2015/03/10 02:47:29]

Remove these checks. We already assume that chrome.hotwordPrivate exists.

[kcarattini, 2015/03/10 04:34:05]

Where do we make that assumption? I don't see it used anywhere else in this
file.

[Anand Mistry (off Chromium), 2015/03/10 04:40:54]

Look at other files in this directory, such as state_manager.js. Also, the check
doesn't make sense since this code is chrome-only and never runs in any context
where hotwordPrivate is not available.

[kcarattini, 2015/03/10 04:50:58]

Done.

+            chrome.hotwordPrivate.getStatus(
+                this.statusDone_.bind(
+                    this,
+                    request.tab || sender.tab || {incognito: true},
+                    sendResponse));
+            return true;
+          }
+          break;
+        case CommandFromPage.CLICKED_OPTIN:
+          if (chrome.hotwordPrivate && chrome.hotwordPrivate.setEnabled &&
+              chrome.hotwordPrivate.getStatus) {
+            chrome.hotwordPrivate.setEnabled(true);
+            // chrome.hotwordPrivate.getStatus(

[Anand Mistry (off Chromium), 2015/03/10 02:47:29]

Remove.

[kcarattini, 2015/03/10 04:34:05]

Done.

+            //     this.injectTab_.bind(this, sender.tab, sendResponse));
+            // return true;
+          }
+          break;
+        // User has explicitly clicked 'no thanks'.
+        case CommandFromPage.CLICKED_NO_OPTIN:
+          if (chrome.hotwordPrivate && chrome.hotwordPrivate.setEnabled) {
+            chrome.hotwordPrivate.setEnabled(false);
+          }
+          break;
+      }
+      return false;
+    },
+
+    /**
+     * Sends the response to the tab.
+     * @param {Tab} tab The tab that the request was sent from.
+     * @param {function(HotwordStatus)} sendResponse Callback function to
+     *     respond to sender.
+     * @param {HotwordStatus} hotwordStatus Status of the hotword extension.
+     * @private
+     */
+    statusDone_: function(tab, sendResponse, hotwordStatus) {
+      var response = {'doNotShowOptinMessage': true};
+
+      if (!tab.incognito && hotwordStatus.available &&
+          !hotwordStatus.enabledSet) {
+        response = hotwordStatus;
+      }
+
+      try {
+        sendResponse(response);
+      } catch (err) {
+        // Suppress the exception thrown by sendResponse() when the page doesn't
+        // specify a response callback in the call to
+        // chrome.runtime.sendMessage().
+        // Unfortunately, there doesn't appear to be a way to detect one-way
+        // messages without explicitly saying in the message itself. This
+        // message is defined as a constant in
+        // extensions/renderer/messaging_bindings.cc
+        if (err.message == 'Attempting to use a disconnected port object')
+          return;
+        throw err;
+      }
+    },
+
     /**
      * Set up event listeners.
      * @private
      */
     setupListeners_: function() {
       if (chrome.runtime.onConnect.hasListener(this.connectListener_))
         return;
 
       chrome.runtime.onConnect.addListener(this.connectListener_);
       chrome.tabs.onCreated.addListener(this.tabCreatedListener_);
       chrome.tabs.onUpdated.addListener(this.tabUpdatedListener_);
       chrome.tabs.onActivated.addListener(this.tabActivatedListener_);
       chrome.windows.onFocusChanged.addListener(
           this.windowFocusChangedListener_);
+      // TODO(kcarattini): Possibly remove the next line. It's probably not
+      // used, but leaving for now to be safe. We should remove it once all
+      // messsage relaying is removed from the content scripts.
+      if (chrome.runtime.onMessage.hasListener(this.messageListener_))
+        return;
+      chrome.runtime.onMessage.addListener(this.messageListener_);

[Anand Mistry (off Chromium), 2015/03/10 02:47:29]

Isn't this one unnecessary? If so, it should be removed.

[kcarattini, 2015/03/10 04:34:05]

Done.

+      chrome.runtime.onMessageExternal.addListener(
+          this.messageListener_);
     },
 
     /**
      * Remove event listeners.
      * @private
      */
     removeListeners_: function() {
       chrome.runtime.onConnect.removeListener(this.connectListener_);
       chrome.tabs.onCreated.removeListener(this.tabCreatedListener_);
       chrome.tabs.onUpdated.removeListener(this.tabUpdatedListener_);
       chrome.tabs.onActivated.removeListener(this.tabActivatedListener_);
       chrome.windows.onFocusChanged.removeListener(
           this.windowFocusChangedListener_);
+      // Don't remove the Message listeners, as we want them listening all
+      // the time,
     },
 
     /**
      * Update event listeners based on the current hotwording state.
      * @private
      */
     updateListeners_: function() {
       if (this.stateManager_.isSometimesOnEnabled()) {
         this.setupListeners_();
       } else {
         this.removeListeners_();
         this.stopHotwording_();
         this.disconnectAllClients_();
       }
     }
   };
 
   return {
     PageAudioManager: PageAudioManager
   };
 });