Experimental hotword-always-on feature.

This CL introduces --enable-app-list-hotword-always-on which
runs the hotword detector background and open the applist
with the voice-search UI when the hotword is detected.

This implementation is mainly for our experiment to measure
the additional power consumption. We don't expect to launch
this directly.

Note that this might be conflicted. Right now it cares like:
- 5 mins idle time disables it
- disable it if some tab is listening the audio (like google home page)

R=xiyuan@chromium.org
BUG=329160
TEST=manually

Review URL: https://codereview.chromium.org/178613005

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@255001 0039d316-1c4b-4281-b951-d872f2087c98

16 files changed, 708 insertions, 15 deletions

diff --git a/chrome/app/generated_resources.grd b/chrome/app/generated_resources.grd
index 3a1d36a..bae3a06 100644
--- a/chrome/app/generated_resources.grd
+++ b/chrome/app/generated_resources.grd
@@ -6805,6 +6805,12 @@ Keep your key file in a safe place. You will need it to create new versions of y
         <message name="IDS_FLAGS_DISABLE_APP_LIST_VOICE_SEARCH_DESCRIPTION" desc="Description of the flag to disable voice search in the app list.">
           Disable voice search in the App Launcher. If disabled, the user won't be able to search by speech.
         </message>
+        <message name="IDS_FLAGS_ENABLE_APP_LIST_HOTWORD_ALWAYS_ON" desc="Name of the flag to enable running the hotword recognizer always.">
+          Always run the hotword recognizer for the App Launcher.
+        </message>
+        <message name="IDS_FLAGS_ENABLE_APP_LIST_HOTWORD_ALWAYS_ON_DESCRIPTION" desc="Description of the flag to enable running the hotword recognizer always.">
+          Experimental implementation to run the hotword recognizer always for the App Launcher. You should not enable this flag unless you understand what this means.
+        </message>
         <message name="IDS_FLAGS_ENABLE_APP_INFO_IN_APP_LIST" desc="Name of the flag to enable the app info context menu option in the app list.">
           Enable the app info dialog.
         </message>
diff --git a/chrome/browser/about_flags.cc b/chrome/browser/about_flags.cc
index 75e58ad..f11a2c4 100644
--- a/chrome/browser/about_flags.cc
+++ b/chrome/browser/about_flags.cc
@@ -1644,6 +1644,13 @@ const Experiment kExperiments[] = {
     SINGLE_VALUE_TYPE(app_list::switches::kDisableVoiceSearch)
   },
   {
+    "enable-app-list-hotword-always-on",
+    IDS_FLAGS_ENABLE_APP_LIST_HOTWORD_ALWAYS_ON,
+    IDS_FLAGS_ENABLE_APP_LIST_HOTWORD_ALWAYS_ON_DESCRIPTION,
+    kOsCrOS,
+    SINGLE_VALUE_TYPE(app_list::switches::kEnableHotwordAlwaysOn)
+  },
+  {
     "enable-app-list-app-info",
     IDS_FLAGS_ENABLE_APP_INFO_IN_APP_LIST,
     IDS_FLAGS_ENABLE_APP_INFO_IN_APP_LIST_DESCRIPTION,
diff --git a/chrome/browser/resources/app_list/speech_manager.js b/chrome/browser/resources/app_list/speech_manager.js
index 1607bbb..30446e8 100644
--- a/chrome/browser/resources/app_list/speech_manager.js
+++ b/chrome/browser/resources/app_list/speech_manager.js
@@ -84,6 +84,7 @@ cr.define('speech', function() {
     } else {
       this.setState_(SpeechState.READY);
     }
+    chrome.send('setHotwordRecognizerState', [true]);
   };
 
   /**
@@ -179,23 +180,21 @@ cr.define('speech', function() {
         return;
       document.body.removeChild(recognizer);
       this.pluginManager_ = null;
+      chrome.send('setHotwordRecognizerState', [false]);
       if (this.state == SpeechState.HOTWORD_RECOGNIZING)
         this.setState(SpeechState.READY);
     }
   };
 
   /**
-   * Called when the app-list bubble is shown.
+   * Starts the hotword recognizer.
    */
-  SpeechManager.prototype.onShown = function() {
-    this.shown_ = true;
+  SpeechManager.prototype.startHotwordRecognition = function() {
     if (!this.pluginManager_)
       return;
 
-    if (this.state == SpeechState.HOTWORD_RECOGNIZING) {
-      console.warn('Already in recognition state...');
+    if (this.state == SpeechState.HOTWORD_RECOGNIZING)
       return;
-    }
 
     this.pluginManager_.startRecognizer();
     this.audioManager_.start();
@@ -203,6 +202,30 @@ cr.define('speech', function() {
   };
 
   /**
+   * Stops the hotword recognizer.
+   */
+  SpeechManager.prototype.stopHotwordRecognition = function() {
+    if (!this.pluginManager_)
+      return;
+
+    if (this.state != SpeechState.HOTWORD_RECOGNIZING)
+      return;
+
+    this.pluginManager_.stopRecognizer();
+    this.audioManager_.stop();
+    this.setState_(SpeechState.READY);
+  };
+
+  /**
+   * Called when the app-list bubble is shown.
+   */
+  SpeechManager.prototype.onShown = function() {
+    this.shown_ = true;
+    if (this.state == SpeechState.READY)
+      this.startHotwordRecognition();
+  };
+
+  /**
    * Called when the app-list bubble is hidden.
    */
   SpeechManager.prototype.onHidden = function() {
diff --git a/chrome/browser/resources/app_list/start_page.js b/chrome/browser/resources/app_list/start_page.js
index e1f586e..6d551f6 100644
--- a/chrome/browser/resources/app_list/start_page.js
+++ b/chrome/browser/resources/app_list/start_page.js
@@ -76,6 +76,20 @@ cr.define('appList.startPage', function() {
   }
 
   /**
+   * Invoked when the hotword recognition should start.
+   */
+  function startHotwordRecognition() {
+    speechManager.startHotwordRecognition();
+  }
+
+  /**
+   * Invoked when the hotword recognition should stop.
+   */
+  function stopHotwordRecognition() {
+    speechManager.stopHotwordRecognition();
+  }
+
+  /**
    * Invoked when the app-list bubble is shown.
    */
   function onAppListShown() {
@@ -101,6 +115,8 @@ cr.define('appList.startPage', function() {
     initialize: initialize,
     setRecommendedApps: setRecommendedApps,
     setHotwordEnabled: setHotwordEnabled,
+    startHotwordRecognition: startHotwordRecognition,
+    stopHotwordRecognition: stopHotwordRecognition,
     onAppListShown: onAppListShown,
     onAppListHidden: onAppListHidden,
     toggleSpeechRecognition: toggleSpeechRecognition
diff --git a/chrome/browser/ui/app_list/hotword_background_activity_delegate.h b/chrome/browser/ui/app_list/hotword_background_activity_delegate.h
new file mode 100644
index 0000000..5190e87
--- /dev/null
+++ b/chrome/browser/ui/app_list/hotword_background_activity_delegate.h
@@ -0,0 +1,26 @@
+// 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.
+
+#ifndef CHROME_BROWSER_UI_APP_LIST_HOTWORD_BACKGROUND_ACTIVITY_DELEGATE_H_
+#define CHROME_BROWSER_UI_APP_LIST_HOTWORD_BACKGROUND_ACTIVITY_DELEGATE_H_
+
+namespace app_list {
+
+// Delegate for HotwordBackgroundActivityMonitor.
+class HotwordBackgroundActivityDelegate {
+ public:
+  virtual ~HotwordBackgroundActivityDelegate() {}
+
+  // Returns the render process ID for the hotword recognizer of the delegate.
+  // The value is used to check if the media request comes from its own render
+  // process.
+  virtual int GetRenderProcessID() = 0;
+
+  // Called when the background hotword recognizer's availablility has changed.
+  virtual void OnHotwordBackgroundActivityChanged() = 0;
+};
+
+}  // namespace app_list
+
+#endif  // CHROME_BROWSER_UI_APP_LIST_HOTWORD_BACKGROUND_ACTIVITY_DELEGATE_H_
diff --git a/chrome/browser/ui/app_list/hotword_background_activity_monitor.cc b/chrome/browser/ui/app_list/hotword_background_activity_monitor.cc
new file mode 100644
index 0000000..a5c16a5
--- /dev/null
+++ b/chrome/browser/ui/app_list/hotword_background_activity_monitor.cc
@@ -0,0 +1,180 @@
+// 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.
+
+#include "chrome/browser/ui/app_list/hotword_background_activity_monitor.h"
+
+#include "chrome/browser/ui/app_list/hotword_background_activity_delegate.h"
+#include "chrome/browser/ui/browser.h"
+#include "chrome/browser/ui/browser_list.h"
+#include "chrome/browser/ui/tabs/tab_strip_model.h"
+#include "chrome/browser/ui/tabs/tab_utils.h"
+#include "content/public/browser/render_process_host.h"
+#include "content/public/browser/web_contents.h"
+
+#if defined(USE_ASH)
+#include "ash/shell.h"
+#endif
+
+#if defined(OS_CHROMEOS)
+#include "chrome/browser/chromeos/idle_detector.h"
+#endif
+
+namespace app_list {
+
+#if defined(OS_CHROMEOS)
+namespace {
+const int kIdleTimeoutInMin = 5;
+}
+#endif
+
+HotwordBackgroundActivityMonitor::HotwordBackgroundActivityMonitor(
+    HotwordBackgroundActivityDelegate* delegate)
+    : delegate_(delegate),
+      locked_(false),
+      is_idle_(false) {
+  BrowserList::AddObserver(this);
+  BrowserList* browsers =
+      BrowserList::GetInstance(chrome::GetActiveDesktop());
+  for (BrowserList::const_iterator iter = browsers->begin();
+       iter != browsers->end(); ++iter) {
+    (*iter)->tab_strip_model()->AddObserver(this);
+  }
+  MediaCaptureDevicesDispatcher::GetInstance()->AddObserver(this);
+
+#if defined(USE_ASH)
+  if (ash::Shell::HasInstance())
+    ash::Shell::GetInstance()->AddShellObserver(this);
+#endif
+
+#if defined(OS_CHROMEOS)
+  idle_detector_.reset(new chromeos::IdleDetector(
+      base::Bind(&HotwordBackgroundActivityMonitor::OnIdleStateChanged,
+                 base::Unretained(this),
+                 false),
+      base::Bind(&HotwordBackgroundActivityMonitor::OnIdleStateChanged,
+                 base::Unretained(this),
+                 true)));
+  idle_detector_->Start(base::TimeDelta::FromMinutes(kIdleTimeoutInMin));
+#endif
+}
+
+HotwordBackgroundActivityMonitor::~HotwordBackgroundActivityMonitor() {
+#if defined(USE_ASH)
+  if (ash::Shell::HasInstance())
+    ash::Shell::GetInstance()->RemoveShellObserver(this);
+#endif
+
+  BrowserList* browsers =
+      BrowserList::GetInstance(chrome::GetActiveDesktop());
+  for (BrowserList::const_iterator iter = browsers->begin();
+       iter != browsers->end(); ++iter) {
+    (*iter)->tab_strip_model()->RemoveObserver(this);
+  }
+  BrowserList::RemoveObserver(this);
+}
+
+bool HotwordBackgroundActivityMonitor::IsHotwordBackgroundActive() {
+  return !is_idle_ && !locked_ && recording_renderer_ids_.empty();
+}
+
+void HotwordBackgroundActivityMonitor::OnBrowserAdded(Browser* browser) {
+  browser->tab_strip_model()->AddObserver(this);
+}
+
+void HotwordBackgroundActivityMonitor::OnBrowserRemoved(Browser* browser) {
+  browser->tab_strip_model()->RemoveObserver(this);
+}
+
+void HotwordBackgroundActivityMonitor::TabClosingAt(
+    TabStripModel* tab_strip_model,
+    content::WebContents* contents,
+    int index) {
+  std::set<int>::const_iterator iter =
+      recording_renderer_ids_.find(contents->GetRenderProcessHost()->GetID());
+  if (iter == recording_renderer_ids_.end())
+    return;
+  recording_renderer_ids_.erase(iter);
+  NotifyActivityChange();
+}
+
+void HotwordBackgroundActivityMonitor::TabChangedAt(
+    content::WebContents* contents,
+    int index,
+    TabStripModelObserver::TabChangeType change_type) {
+  // Audio recording state change may emit TabChangedAt with ALL change_type.
+  if (change_type != TabStripModelObserver::ALL)
+    return;
+
+  bool was_empty = recording_renderer_ids_.empty();
+
+  bool recording = chrome::GetTabMediaStateForContents(contents) ==
+      TAB_MEDIA_STATE_RECORDING;
+  recording |= recording_contents_for_test_.find(contents) !=
+      recording_contents_for_test_.end();
+  if (recording) {
+    recording_renderer_ids_.insert(contents->GetRenderProcessHost()->GetID());
+  } else {
+    recording_renderer_ids_.erase(contents->GetRenderProcessHost()->GetID());
+  }
+  if (was_empty != recording_renderer_ids_.empty())
+    NotifyActivityChange();
+}
+
+#if defined(USE_ASH)
+void HotwordBackgroundActivityMonitor::OnLockStateChanged(bool locked) {
+  if (locked_ == locked)
+    return;
+
+  // TODO(mukai): consider non-ash environment. Right now this feature is
+  // ChromeOS only, so ash always exists.
+  locked_ = locked;
+  NotifyActivityChange();
+}
+#endif
+
+void HotwordBackgroundActivityMonitor::OnRequestUpdate(
+    int render_process_id,
+    int render_view_id,
+    const content::MediaStreamDevice& device,
+    const content::MediaRequestState state) {
+  // Don't care the request from myself.
+  if (render_process_id == delegate_->GetRenderProcessID())
+    return;
+
+  bool was_empty = recording_renderer_ids_.empty();
+  if (state == content::MEDIA_REQUEST_STATE_REQUESTED ||
+      state == content::MEDIA_REQUEST_STATE_PENDING_APPROVAL ||
+      state == content::MEDIA_REQUEST_STATE_OPENING ||
+      state == content::MEDIA_REQUEST_STATE_DONE) {
+    recording_renderer_ids_.insert(render_process_id);
+  } else {
+    recording_renderer_ids_.erase(render_process_id);
+  }
+  if (was_empty != recording_renderer_ids_.empty())
+    NotifyActivityChange();
+}
+
+void HotwordBackgroundActivityMonitor::OnIdleStateChanged(bool is_idle) {
+  if (is_idle_ == is_idle)
+    return;
+
+  is_idle_ = is_idle;
+  NotifyActivityChange();
+}
+
+void HotwordBackgroundActivityMonitor::NotifyActivityChange() {
+  delegate_->OnHotwordBackgroundActivityChanged();
+}
+
+void HotwordBackgroundActivityMonitor::AddWebContentsToWhitelistForTest(
+    content::WebContents* contents) {
+  recording_contents_for_test_.insert(contents);
+}
+
+void HotwordBackgroundActivityMonitor::RemoveWebContentsFromWhitelistForTest(
+    content::WebContents* contents) {
+  recording_contents_for_test_.erase(contents);
+}
+
+}  // namespace app_list
diff --git a/chrome/browser/ui/app_list/hotword_background_activity_monitor.h b/chrome/browser/ui/app_list/hotword_background_activity_monitor.h
new file mode 100644
index 0000000..6a02d1c
--- /dev/null
+++ b/chrome/browser/ui/app_list/hotword_background_activity_monitor.h
@@ -0,0 +1,104 @@
+// 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.
+
+#ifndef CHROME_BROWSER_UI_APP_LIST_HOTWORD_BACKGROUND_ACTIVITY_MONITOR_H_
+#define CHROME_BROWSER_UI_APP_LIST_HOTWORD_BACKGROUND_ACTIVITY_MONITOR_H_
+
+#include <set>
+
+#include "base/basictypes.h"
+#include "base/observer_list.h"
+#include "chrome/browser/media/media_capture_devices_dispatcher.h"
+#include "chrome/browser/ui/browser_list_observer.h"
+#include "chrome/browser/ui/tabs/tab_strip_model_observer.h"
+
+#if defined(USE_ASH)
+#include "ash/shell_observer.h"
+#endif
+
+#if defined(OS_CHROMEOS)
+namespace chromeos {
+class IdleDetector;
+}
+#endif
+
+namespace app_list {
+
+class HotwordBackgroundActivityDelegate;
+
+// A monitor to check the user activity and reports the availability of
+// background hotword recognizer. Otherwise, the background hotword recognizer
+// may conflict with foreground browser activity like voice search in
+// Google homepage.
+class HotwordBackgroundActivityMonitor
+    : public chrome::BrowserListObserver,
+      public TabStripModelObserver,
+#if defined(USE_ASH)
+      public ash::ShellObserver,
+#endif
+      public MediaCaptureDevicesDispatcher::Observer {
+ public:
+  explicit HotwordBackgroundActivityMonitor(
+      HotwordBackgroundActivityDelegate* delegate);
+  virtual ~HotwordBackgroundActivityMonitor();
+
+  bool IsHotwordBackgroundActive();
+
+ private:
+  friend class HotwordBackgroundActivityMonitorTest;
+
+  // chrome::BrowserListObserver overrides:
+  virtual void OnBrowserAdded(Browser* browser) OVERRIDE;
+  virtual void OnBrowserRemoved(Browser* browser) OVERRIDE;
+
+  // TabStripModelObserver overrides:
+  virtual void TabClosingAt(
+      TabStripModel* tab_strip_model,
+      content::WebContents* contents,
+      int index) OVERRIDE;
+  virtual void TabChangedAt(
+      content::WebContents* contents,
+      int index,
+      TabStripModelObserver::TabChangeType change_type) OVERRIDE;
+
+#if defined(USE_ASH)
+  // ash::ShellObserver overrides:
+  virtual void OnLockStateChanged(bool locked) OVERRIDE;
+#endif
+
+  // MediaCaptureDevicesDispatcher::Observer overrides:
+  virtual void OnRequestUpdate(
+      int render_process_id,
+      int render_view_id,
+      const content::MediaStreamDevice& device,
+      const content::MediaRequestState state) OVERRIDE;
+
+  // Called when the idle state changed.
+  void OnIdleStateChanged(bool is_idle);
+
+  void NotifyActivityChange();
+
+  // Adds/Removes WebContents for the whitelist of tab-recording for testing.
+  void AddWebContentsToWhitelistForTest(
+      content::WebContents* contents);
+  void RemoveWebContentsFromWhitelistForTest(
+      content::WebContents* contents);
+
+  HotwordBackgroundActivityDelegate* delegate_;
+
+  bool locked_;
+  bool is_idle_;
+  std::set<int> recording_renderer_ids_;
+  std::set<content::WebContents*> recording_contents_for_test_;
+
+#if defined(OS_CHROMEOS)
+  scoped_ptr<chromeos::IdleDetector> idle_detector_;
+#endif
+
+  DISALLOW_COPY_AND_ASSIGN(HotwordBackgroundActivityMonitor);
+};
+
+}  // namespace app_list
+
+#endif  // CHROME_BROWSER_UI_APP_LIST_HOTWORD_BACKGROUND_ACTIVITY_MONITOR_H_
diff --git a/chrome/browser/ui/app_list/hotword_background_activity_monitor_unittest.cc b/chrome/browser/ui/app_list/hotword_background_activity_monitor_unittest.cc
new file mode 100644
index 0000000..6badf6d
--- /dev/null
+++ b/chrome/browser/ui/app_list/hotword_background_activity_monitor_unittest.cc
@@ -0,0 +1,235 @@
+// 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.
+
+#include "chrome/browser/ui/app_list/hotword_background_activity_monitor.h"
+
+#include "chrome/browser/ui/app_list/hotword_background_activity_delegate.h"
+#include "chrome/browser/ui/tabs/tab_strip_model.h"
+#include "chrome/test/base/browser_with_test_window_test.h"
+#include "chrome/test/base/testing_profile.h"
+#include "content/public/browser/render_process_host.h"
+#include "content/public/common/child_process_host.h"
+
+#if defined(USE_ASH)
+#include "ash/shell.h"
+#endif
+
+namespace app_list {
+
+class HotwordBackgroundActivityMonitorTest
+    : public BrowserWithTestWindowTest,
+      public HotwordBackgroundActivityDelegate {
+ public:
+  HotwordBackgroundActivityMonitorTest() : changed_count_(0) {}
+  virtual ~HotwordBackgroundActivityMonitorTest() {}
+
+  // testing::Test overrides:
+  virtual void SetUp() OVERRIDE {
+    BrowserWithTestWindowTest::SetUp();
+    monitor_.reset(new HotwordBackgroundActivityMonitor(this));
+  }
+  virtual void TearDown() OVERRIDE {
+    monitor_.reset();
+    BrowserWithTestWindowTest::TearDown();
+  }
+
+ protected:
+  int GetChangedCountAndReset() {
+    int count = changed_count_;
+    changed_count_ = 0;
+    return count;
+  }
+
+  bool IsHotwordBackgroundActive() {
+    return monitor_->IsHotwordBackgroundActive();
+  }
+
+  // Invokes the idle test explicitly.
+  // TODO(mukai): make IdleDetector testable.
+  void SetIdleState(bool is_idle) {
+    monitor_->OnIdleStateChanged(is_idle);
+  }
+
+  void UpdateMediaRequest(int render_process_id, bool requesting) {
+    monitor_->OnRequestUpdate(
+        render_process_id,
+        0 /* don't care render_view_id */,
+        content::MediaStreamDevice() /* don't care the device */,
+        requesting ? content::MEDIA_REQUEST_STATE_REQUESTED :
+        content::MEDIA_REQUEST_STATE_CLOSING);
+  }
+
+  void AddWebContentsToWhitelist(content::WebContents* contents) {
+    monitor_->AddWebContentsToWhitelistForTest(contents);
+  }
+
+  void RemoveWebContentsFromWhitelist(content::WebContents* contents) {
+    monitor_->RemoveWebContentsFromWhitelistForTest(contents);
+  }
+
+  // HotwordBackgroundActivityDelegate overrides:
+  virtual int GetRenderProcessID() OVERRIDE {
+    // Use the invalid id for tests, because it cannot overlap with any existing
+    // ids.
+    return content::ChildProcessHost::kInvalidUniqueID;
+  }
+
+ private:
+  // HotwordBackgroundActivityDelegate overrides:
+  virtual void OnHotwordBackgroundActivityChanged() OVERRIDE {
+    ++changed_count_;
+  }
+
+  int changed_count_;
+  scoped_ptr<HotwordBackgroundActivityMonitor> monitor_;
+
+  DISALLOW_COPY_AND_ASSIGN(HotwordBackgroundActivityMonitorTest);
+};
+
+#if defined(USE_ASH)
+TEST_F(HotwordBackgroundActivityMonitorTest, LockStateTest) {
+  if (!ash::Shell::HasInstance())
+    return;
+
+  ASSERT_TRUE(IsHotwordBackgroundActive());
+
+  ash::Shell::GetInstance()->OnLockStateChanged(true);
+  EXPECT_EQ(1, GetChangedCountAndReset());
+  EXPECT_FALSE(IsHotwordBackgroundActive());
+
+  ash::Shell::GetInstance()->OnLockStateChanged(false);
+  EXPECT_EQ(1, GetChangedCountAndReset());
+  EXPECT_TRUE(IsHotwordBackgroundActive());
+}
+#endif
+
+TEST_F(HotwordBackgroundActivityMonitorTest, IdleStateTest) {
+  ASSERT_TRUE(IsHotwordBackgroundActive());
+
+  SetIdleState(true);
+  EXPECT_EQ(1, GetChangedCountAndReset());
+  EXPECT_FALSE(IsHotwordBackgroundActive());
+
+#if defined(USE_ASH)
+  if (ash::Shell::HasInstance()) {
+    ash::Shell::GetInstance()->OnLockStateChanged(true);
+    EXPECT_EQ(1, GetChangedCountAndReset());
+    EXPECT_FALSE(IsHotwordBackgroundActive());
+
+    ash::Shell::GetInstance()->OnLockStateChanged(false);
+    EXPECT_EQ(1, GetChangedCountAndReset());
+    EXPECT_FALSE(IsHotwordBackgroundActive());
+  }
+#endif
+
+  SetIdleState(false);
+  EXPECT_EQ(1, GetChangedCountAndReset());
+  EXPECT_TRUE(IsHotwordBackgroundActive());
+}
+
+TEST_F(HotwordBackgroundActivityMonitorTest, MediaRequests) {
+  ASSERT_TRUE(IsHotwordBackgroundActive());
+
+  // Request from itself should be ignored.
+  UpdateMediaRequest(GetRenderProcessID(), true);
+  EXPECT_EQ(0, GetChangedCountAndReset());
+  EXPECT_TRUE(IsHotwordBackgroundActive());
+
+  int id1 = GetRenderProcessID() + 1;
+  int id2 = GetRenderProcessID() + 2;
+
+  UpdateMediaRequest(id1, true);
+  EXPECT_EQ(1, GetChangedCountAndReset());
+  EXPECT_FALSE(IsHotwordBackgroundActive());
+
+  UpdateMediaRequest(id2, true);
+  EXPECT_EQ(0, GetChangedCountAndReset());
+  EXPECT_FALSE(IsHotwordBackgroundActive());
+
+  UpdateMediaRequest(id2, false);
+  EXPECT_EQ(0, GetChangedCountAndReset());
+  EXPECT_FALSE(IsHotwordBackgroundActive());
+
+  UpdateMediaRequest(id1, false);
+  EXPECT_EQ(1, GetChangedCountAndReset());
+  EXPECT_TRUE(IsHotwordBackgroundActive());
+}
+
+TEST_F(HotwordBackgroundActivityMonitorTest, TabTests) {
+  ASSERT_TRUE(IsHotwordBackgroundActive());
+
+  content::WebContents* contents = content::WebContents::Create(
+      content::WebContents::CreateParams(profile()));
+  TabStripModel* tab_strip_model = browser()->tab_strip_model();
+  tab_strip_model->AddWebContents(
+      contents, 0, content::PAGE_TRANSITION_LINK, TabStripModel::ADD_ACTIVE);
+  EXPECT_EQ(0, GetChangedCountAndReset());
+  EXPECT_TRUE(IsHotwordBackgroundActive());
+
+  AddWebContentsToWhitelist(contents);
+  tab_strip_model->UpdateWebContentsStateAt(0, TabStripModelObserver::ALL);
+
+  EXPECT_EQ(1, GetChangedCountAndReset());
+  EXPECT_FALSE(IsHotwordBackgroundActive());
+
+  // Tab could be closed without UpdateWebContentsStateAt().
+  RemoveWebContentsFromWhitelist(contents);
+  tab_strip_model->CloseWebContentsAt(0, TabStripModel::CLOSE_NONE);
+  EXPECT_EQ(1, GetChangedCountAndReset());
+  EXPECT_TRUE(IsHotwordBackgroundActive());
+}
+
+TEST_F(HotwordBackgroundActivityMonitorTest, MediaAndTabCombined) {
+  ASSERT_TRUE(IsHotwordBackgroundActive());
+
+  TabStripModel* tab_strip_model = browser()->tab_strip_model();
+  content::WebContents* contents = content::WebContents::Create(
+      content::WebContents::CreateParams(profile()));
+  int contents_id = contents->GetRenderProcessHost()->GetID();
+  int extension_id = contents_id + 1;
+  ASSERT_NE(GetRenderProcessID(), extension_id);
+
+  tab_strip_model->AddWebContents(
+      contents, 0, content::PAGE_TRANSITION_LINK, TabStripModel::ADD_ACTIVE);
+  EXPECT_EQ(0, GetChangedCountAndReset());
+  EXPECT_TRUE(IsHotwordBackgroundActive());
+
+  // Another recognizer for the tab has started.
+  UpdateMediaRequest(extension_id, true);
+  EXPECT_EQ(1, GetChangedCountAndReset());
+  EXPECT_FALSE(IsHotwordBackgroundActive());
+
+  // Hotword is recognized -- switch to the speech recognition in the tab.
+  AddWebContentsToWhitelist(contents);
+  UpdateMediaRequest(contents_id, true);
+  UpdateMediaRequest(extension_id, false);
+  tab_strip_model->UpdateWebContentsStateAt(0, TabStripModelObserver::ALL);
+
+  EXPECT_EQ(0, GetChangedCountAndReset());
+  EXPECT_FALSE(IsHotwordBackgroundActive());
+
+  // The speech recognition has ended.
+  RemoveWebContentsFromWhitelist(contents);
+  tab_strip_model->UpdateWebContentsStateAt(0, TabStripModelObserver::ALL);
+  UpdateMediaRequest(extension_id, true);
+
+  EXPECT_EQ(2, GetChangedCountAndReset());
+  EXPECT_FALSE(IsHotwordBackgroundActive());
+
+  // Switches to the speech recognition state again.
+  AddWebContentsToWhitelist(contents);
+  UpdateMediaRequest(contents_id, true);
+  UpdateMediaRequest(extension_id, false);
+  tab_strip_model->UpdateWebContentsStateAt(0, TabStripModelObserver::ALL);
+
+  EXPECT_EQ(0, GetChangedCountAndReset());
+  EXPECT_FALSE(IsHotwordBackgroundActive());
+
+  // And then close the tab during the speech recognition.
+  tab_strip_model->CloseWebContentsAt(0, TabStripModel::CLOSE_NONE);
+  EXPECT_EQ(1, GetChangedCountAndReset());
+  EXPECT_TRUE(IsHotwordBackgroundActive());
+}
+
+}  // namespace app_list
diff --git a/chrome/browser/ui/app_list/start_page_service.cc b/chrome/browser/ui/app_list/start_page_service.cc
index 0f6c70a..641c66b 100644
--- a/chrome/browser/ui/app_list/start_page_service.cc
+++ b/chrome/browser/ui/app_list/start_page_service.cc
@@ -12,6 +12,7 @@
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/media/media_stream_infobar_delegate.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/ui/app_list/app_list_service.h"
 #include "chrome/browser/ui/app_list/recommended_apps.h"
 #include "chrome/browser/ui/app_list/start_page_observer.h"
 #include "chrome/browser/ui/app_list/start_page_service_factory.h"
@@ -171,20 +172,28 @@ void StartPageService::OnSpeechSoundLevelChanged(int16 level) {
 
 void StartPageService::OnSpeechRecognitionStateChanged(
     SpeechRecognitionState new_state) {
-  if (!InSpeechRecognition(state_) && InSpeechRecognition(new_state)) {
+  SpeechRecognitionState old_state = state_;
+  state_ = new_state;
+
+  if (!InSpeechRecognition(old_state) && InSpeechRecognition(new_state)) {
     if (!speech_button_toggled_manually_ &&
-        state_ == SPEECH_RECOGNITION_HOTWORD_LISTENING) {
+        old_state == SPEECH_RECOGNITION_HOTWORD_LISTENING) {
       RecordAction(UserMetricsAction("AppList_HotwordRecognized"));
+      AppListService* app_list_service =
+          AppListService::Get(chrome::GetActiveDesktop());
+      if (!app_list_service->IsAppListVisible())
+       app_list_service->Show();
     } else {
       RecordAction(UserMetricsAction("AppList_VoiceSearchStartedManually"));
     }
-  } else if (InSpeechRecognition(state_) && !InSpeechRecognition(new_state) &&
+  } else if (InSpeechRecognition(old_state) &&
+             !InSpeechRecognition(new_state) &&
              !speech_result_obtained_) {
     RecordAction(UserMetricsAction("AppList_VoiceSearchCanceled"));
   }
   speech_button_toggled_manually_ = false;
   speech_result_obtained_ = false;
-  state_ = new_state;
+
   FOR_EACH_OBSERVER(StartPageObserver,
                     observers_,
                     OnSpeechRecognitionStateChanged(new_state));
diff --git a/chrome/browser/ui/webui/app_list/start_page_handler.cc b/chrome/browser/ui/webui/app_list/start_page_handler.cc
index 97cd075..95ad77e 100644
--- a/chrome/browser/ui/webui/app_list/start_page_handler.cc
+++ b/chrome/browser/ui/webui/app_list/start_page_handler.cc
@@ -16,6 +16,7 @@
 #include "chrome/browser/search/hotword_service.h"
 #include "chrome/browser/ui/app_list/app_list_controller_delegate.h"
 #include "chrome/browser/ui/app_list/app_list_service.h"
+#include "chrome/browser/ui/app_list/hotword_background_activity_monitor.h"
 #include "chrome/browser/ui/app_list/recommended_apps.h"
 #include "chrome/browser/ui/app_list/start_page_service.h"
 #include "chrome/browser/ui/host_desktop.h"
@@ -24,12 +25,14 @@
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
+#include "content/public/browser/render_process_host.h"
+#include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_view.h"
 #include "content/public/browser/web_ui.h"
+#include "content/public/common/child_process_host.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/common/extension.h"
 #include "ui/app_list/app_list_switches.h"
-#include "ui/app_list/speech_ui_model_observer.h"
 #include "ui/events/event_constants.h"
 
 namespace app_list {
@@ -58,7 +61,11 @@ scoped_ptr<base::DictionaryValue> CreateAppInfo(
 
 }  // namespace
 
-StartPageHandler::StartPageHandler() : recommended_apps_(NULL) {}
+StartPageHandler::StartPageHandler()
+    : recommended_apps_(NULL),
+      has_hotword_recognizer_(false),
+      last_state_(SPEECH_RECOGNITION_OFF) {
+}
 
 StartPageHandler::~StartPageHandler() {
   if (recommended_apps_)
@@ -73,6 +80,10 @@ void StartPageHandler::RegisterMessages() {
       "launchApp",
       base::Bind(&StartPageHandler::HandleLaunchApp, base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
+      "setHotwordRecognizerState",
+      base::Bind(&StartPageHandler::HandleHotwordRecognizerState,
+                 base::Unretained(this)));
+  web_ui()->RegisterMessageCallback(
       "speechResult",
       base::Bind(&StartPageHandler::HandleSpeechResult,
                  base::Unretained(this)));
@@ -114,6 +125,24 @@ void StartPageHandler::Observe(int type,
 #endif
 }
 
+int StartPageHandler::GetRenderProcessID() {
+  if (!web_ui())
+    return content::ChildProcessHost::kInvalidUniqueID;
+  content::WebContents* web_contents = web_ui()->GetWebContents();
+  return web_contents->GetRenderProcessHost()->GetID();
+}
+
+void StartPageHandler::OnHotwordBackgroundActivityChanged() {
+#if defined(OS_CHROMEOS)
+  if (has_hotword_recognizer_ && switches::IsHotwordAlwaysOnEnabled()) {
+    web_ui()->CallJavascriptFunction(
+        (hotword_monitor_ && hotword_monitor_->IsHotwordBackgroundActive()) ?
+        "appList.startPage.startHotwordRecognition" :
+        "appList.startPage.stopHotwordRecognition");
+  }
+#endif
+}
+
 void StartPageHandler::OnRecommendedAppsChanged() {
   SendRecommendedApps();
 }
@@ -193,10 +222,16 @@ void StartPageHandler::HandleInitialize(const base::ListValue* args) {
                    content::Source<Profile>(profile));
     registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED,
                    content::Source<Profile>(profile));
+    hotword_monitor_.reset(new HotwordBackgroundActivityMonitor(this));
   }
 #endif
 }
 
+bool StartPageHandler::ShouldRunHotwordBackground() {
+  return has_hotword_recognizer_ && switches::IsHotwordAlwaysOnEnabled() &&
+      hotword_monitor_ && hotword_monitor_->IsHotwordBackgroundActive();
+}
+
 void StartPageHandler::HandleLaunchApp(const base::ListValue* args) {
   std::string app_id;
   CHECK(args->GetString(0, &app_id));
@@ -220,6 +255,15 @@ void StartPageHandler::HandleLaunchApp(const base::ListValue* args) {
                           ui::EF_NONE);
 }
 
+void StartPageHandler::HandleHotwordRecognizerState(
+    const base::ListValue* args) {
+  CHECK(args->GetBoolean(0, &has_hotword_recognizer_));
+  if (last_state_ == SPEECH_RECOGNITION_READY && ShouldRunHotwordBackground()) {
+    web_ui()->CallJavascriptFunction(
+        "appList.startPage.startHotwordRecognition");
+  }
+}
+
 void StartPageHandler::HandleSpeechResult(const base::ListValue* args) {
   base::string16 query;
   bool is_final = false;
@@ -256,10 +300,16 @@ void StartPageHandler::HandleSpeechRecognition(const base::ListValue* args) {
   else if (state_string == "STOPPING")
     new_state = SPEECH_RECOGNITION_STOPPING;
 
-  StartPageService* service =
-      StartPageService::Get(Profile::FromWebUI(web_ui()));
+  last_state_ = new_state;
+  Profile* profile = Profile::FromWebUI(web_ui());
+  StartPageService* service = StartPageService::Get(profile);
   if (service)
     service->OnSpeechRecognitionStateChanged(new_state);
+
+  if (new_state == SPEECH_RECOGNITION_READY && ShouldRunHotwordBackground()) {
+    web_ui()->CallJavascriptFunction(
+        "appList.startPage.startHotwordRecognition");
+  }
 }
 
 }  // namespace app_list
diff --git a/chrome/browser/ui/webui/app_list/start_page_handler.h b/chrome/browser/ui/webui/app_list/start_page_handler.h
index fb082ac..3b05af2 100644
--- a/chrome/browser/ui/webui/app_list/start_page_handler.h
+++ b/chrome/browser/ui/webui/app_list/start_page_handler.h
@@ -8,10 +8,12 @@
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/prefs/pref_change_registrar.h"
+#include "chrome/browser/ui/app_list/hotword_background_activity_delegate.h"
 #include "chrome/browser/ui/app_list/recommended_apps_observer.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/web_ui_message_handler.h"
+#include "ui/app_list/speech_ui_model_observer.h"
 
 namespace base {
 class ListValue;
@@ -19,11 +21,13 @@ class ListValue;
 
 namespace app_list {
 
+class HotwordBackgroundActivityMonitor;
 class RecommendedApps;
 
 // Handler for the app launcher start page.
 class StartPageHandler : public content::WebUIMessageHandler,
                          public content::NotificationObserver,
+                         public HotwordBackgroundActivityDelegate,
                          public RecommendedAppsObserver {
  public:
   StartPageHandler();
@@ -33,11 +37,15 @@ class StartPageHandler : public content::WebUIMessageHandler,
   // content::WebUIMessageHandler overrides:
   virtual void RegisterMessages() OVERRIDE;
 
-  // Overridden from content::NotificationObserver:
+  // content::NotificationObserver overrides:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
+  // HotwordBackgroundActivityDelegate overrides:
+  virtual int GetRenderProcessID() OVERRIDE;
+  virtual void OnHotwordBackgroundActivityChanged() OVERRIDE;
+
   // RecommendedAppsObserver overrdies:
   virtual void OnRecommendedAppsChanged() OVERRIDE;
 
@@ -56,14 +64,21 @@ class StartPageHandler : public content::WebUIMessageHandler,
   void SynchronizeHotwordEnabled();
 #endif
 
+  // Returns true if the hotword recognizer should run background.
+  bool ShouldRunHotwordBackground();
+
   // JS callbacks.
   void HandleInitialize(const base::ListValue* args);
   void HandleLaunchApp(const base::ListValue* args);
+  void HandleHotwordRecognizerState(const base::ListValue* args);
   void HandleSpeechResult(const base::ListValue* args);
   void HandleSpeechSoundLevel(const base::ListValue* args);
   void HandleSpeechRecognition(const base::ListValue* args);
 
   RecommendedApps* recommended_apps_;  // Not owned.
+  bool has_hotword_recognizer_;
+  scoped_ptr<HotwordBackgroundActivityMonitor> hotword_monitor_;
+  SpeechRecognitionState last_state_;
   PrefChangeRegistrar pref_change_registrar_;
   content::NotificationRegistrar registrar_;
 
diff --git a/chrome/chrome_browser_ui.gypi b/chrome/chrome_browser_ui.gypi
index b86c146..775ec97 100644
--- a/chrome/chrome_browser_ui.gypi
+++ b/chrome/chrome_browser_ui.gypi
@@ -173,6 +173,9 @@
         'browser/ui/app_list/extension_uninstaller.h',
         'browser/ui/app_list/fast_show_pickler.cc',
         'browser/ui/app_list/fast_show_pickler.h',
+        'browser/ui/app_list/hotword_background_activity_delegate.h',
+        'browser/ui/app_list/hotword_background_activity_monitor.cc',
+        'browser/ui/app_list/hotword_background_activity_monitor.h',
         'browser/ui/app_list/keep_alive_service.h',
         'browser/ui/app_list/keep_alive_service_impl.cc',
         'browser/ui/app_list/keep_alive_service_impl.h',
diff --git a/chrome/chrome_tests_unit.gypi b/chrome/chrome_tests_unit.gypi
index 66df9ac0..ae53bba 100644
--- a/chrome/chrome_tests_unit.gypi
+++ b/chrome/chrome_tests_unit.gypi
@@ -2719,6 +2719,7 @@
           ],
           'sources': [
             'browser/ui/app_list/extension_app_model_builder_unittest.cc',
+            'browser/ui/app_list/hotword_background_activity_monitor_unittest.cc',
             'browser/ui/app_list/test/fast_show_pickler_unittest.cc',
           ],
         }],
diff --git a/ui/app_list/app_list_switches.cc b/ui/app_list/app_list_switches.cc
index bbc7d06..77a72f0 100644
--- a/ui/app_list/app_list_switches.cc
+++ b/ui/app_list/app_list_switches.cc
@@ -18,6 +18,10 @@ const char kDisableFolderUI[] = "disable-app-list-folder-ui";
 // If set, the voice search is disabled in app list UI.
 const char kDisableVoiceSearch[] = "disable-app-list-voice-search";
 
+// If set, it will always listen to the audio locally and open the app-list
+// when the hotword is recognized.
+const char kEnableHotwordAlwaysOn[] = "enable-app-list-hotword-always-on";
+
 // If set, the app info context menu item is available in the app list UI.
 const char kEnableAppInfo[] = "enable-app-list-app-info";
 
@@ -35,6 +39,15 @@ bool IsVoiceSearchEnabled() {
 #endif
 }
 
+bool IsHotwordAlwaysOnEnabled() {
+#if defined(OS_CHROMEOS)
+  return IsVoiceSearchEnabled() &&
+      CommandLine::ForCurrentProcess()->HasSwitch(kEnableHotwordAlwaysOn);
+#else
+  return false;
+#endif
+}
+
 bool IsAppInfoEnabled() {
   return CommandLine::ForCurrentProcess()->HasSwitch(kEnableAppInfo);
 }
diff --git a/ui/app_list/app_list_switches.h b/ui/app_list/app_list_switches.h
index 9b2b633..853a32f 100644
--- a/ui/app_list/app_list_switches.h
+++ b/ui/app_list/app_list_switches.h
@@ -13,12 +13,15 @@ namespace switches {
 APP_LIST_EXPORT extern const char kEnableExperimentalAppList[];
 APP_LIST_EXPORT extern const char kDisableFolderUI[];
 APP_LIST_EXPORT extern const char kDisableVoiceSearch[];
+APP_LIST_EXPORT extern const char kEnableHotwordAlwaysOn[];
 APP_LIST_EXPORT extern const char kEnableAppInfo[];
 
 bool APP_LIST_EXPORT IsFolderUIEnabled();
 
 bool APP_LIST_EXPORT IsVoiceSearchEnabled();
 
+bool APP_LIST_EXPORT IsHotwordAlwaysOnEnabled();
+
 bool APP_LIST_EXPORT IsAppInfoEnabled();
 
 bool APP_LIST_EXPORT IsExperimentalAppListEnabled();
diff --git a/ui/app_list/views/app_list_view.cc b/ui/app_list/views/app_list_view.cc
index 8ac7f24..b1f15f4 100644
--- a/ui/app_list/views/app_list_view.cc
+++ b/ui/app_list/views/app_list_view.cc
@@ -329,6 +329,8 @@ void AppListView::InitAsBubbleInternal(gfx::NativeView parent,
   GetWidget()->Hide();
 #endif
 
+  OnSpeechRecognitionStateChanged(delegate_->GetSpeechUI()->state());
+
   if (delegate_)
     delegate_->ViewInitialized();
 }