Revert 168104 because it broke interactive_ui_tests and browser_tests on debug builds.

===
1) added "idle" and "locked" transitions to idle.onStateChanged
2) Per-app/extension idle threshold, settable via idle.setDetectionInterval
3) Bug fixes

BUG=143275

Review URL: https://chromiumcodereview.appspot.com/10985056

TBR=courage@chromium.org
Review URL: https://codereview.chromium.org/11418024

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

21 files changed, 470 insertions, 1189 deletions

diff --git a/chrome/browser/extensions/api/idle/idle_api.cc b/chrome/browser/extensions/api/idle/idle_api.cc
index 1cd1fe4..178afb4 100644
--- a/chrome/browser/extensions/api/idle/idle_api.cc
+++ b/chrome/browser/extensions/api/idle/idle_api.cc
@@ -4,59 +4,273 @@
 
 #include "chrome/browser/extensions/api/idle/idle_api.h"
 
+#include <algorithm>
+#include <map>
+#include <string>
+
 #include "base/bind.h"
 #include "base/callback.h"
+#include "base/json/json_writer.h"
+#include "base/message_loop.h"
+#include "base/stl_util.h"
+#include "base/time.h"
+#include "chrome/browser/extensions/event_router.h"
+#include "chrome/browser/extensions/extension_host.h"
 #include "chrome/browser/extensions/api/idle/idle_api_constants.h"
-#include "chrome/browser/extensions/api/idle/idle_manager.h"
-#include "chrome/browser/extensions/api/idle/idle_manager_factory.h"
+#include "chrome/browser/extensions/extension_service.h"
+#include "chrome/browser/extensions/extension_system.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/common/extensions/extension.h"
+#include "content/public/browser/render_view_host.h"
+
+using extensions::ExtensionIdleCache;
+using extensions::ExtensionIdleEventRouter;
+using extensions::ExtensionIdleQueryStateFunction;
+
+namespace keys = extensions::idle_api_constants;
 
 namespace {
 
+const int kIdlePollInterval = 1;  // Number of seconds between status checks
+                                  // when polling for active.
+const int kThrottleInterval = 1;  // Number of seconds to throttle idle checks
+                                  // for. Return the previously checked idle
+                                  // state if the next check is faster than this
 const int kMinThreshold = 15;  // In seconds.  Set >1 sec for security concerns.
 const int kMaxThreshold = 4*60*60;  // Four hours, in seconds. Not set
                                     // arbitrarily high for security concerns.
+const unsigned int kMaxCacheSize = 100;  // Number of state queries to cache.
 
-int ClampThreshold(int threshold) {
-  if (threshold < kMinThreshold) {
-    threshold = kMinThreshold;
-  } else if (threshold > kMaxThreshold) {
-    threshold = kMaxThreshold;
-  }
+// Calculates the error query interval has in respect to idle interval.
+// The error is defined as amount of the query interval that is not part of the
+// idle interval.
+double QueryErrorFromIdle(double idle_start,
+                          double idle_end,
+                          double query_start,
+                          double query_end) {
+  return query_end - idle_end + std::max(0., idle_start - query_start);
+}
+
+// Internal class which is used to poll for changes in the system idle state.
+class ExtensionIdlePollingTask {
+ public:
+  explicit ExtensionIdlePollingTask(int threshold, IdleState last_state,
+      Profile* profile) : threshold_(threshold), last_state_(last_state),
+                          profile_(profile) {}
+
+  // Check if we're active; then restart the polling task. Do this till we are
+  // are in active state.
+  void CheckIdleState();
+  void IdleStateCallback(IdleState state);
+
+  // Create a poll task to check for Idle state
+  static void CreateNewPollTask(int threshold, IdleState state,
+                                Profile* profile);
+
+ private:
+  int threshold_;
+  IdleState last_state_;
+  Profile* profile_;
+
+  static bool poll_task_running_;
+
+  DISALLOW_COPY_AND_ASSIGN(ExtensionIdlePollingTask);
+};
+
+// Implementation of ExtensionIdlePollingTask.
+bool ExtensionIdlePollingTask::poll_task_running_ = false;
+
+void ExtensionIdlePollingTask::IdleStateCallback(IdleState current_state) {
+  // If we just came into an active state, notify the extension.
+  if (IDLE_STATE_ACTIVE == current_state && last_state_ != current_state)
+    ExtensionIdleEventRouter::OnIdleStateChange(profile_,
+                                                            current_state);
+
+  ExtensionIdlePollingTask::poll_task_running_ = false;
+
+  ExtensionIdleCache::UpdateCache(threshold_, current_state);
+
+  // Startup another polling task as we exit.
+  if (current_state != IDLE_STATE_ACTIVE)
+    ExtensionIdlePollingTask::CreateNewPollTask(threshold_, current_state,
+                                                profile_);
+
+  // This instance won't be needed anymore.
+  delete this;
+}
+
+void ExtensionIdlePollingTask::CheckIdleState() {
+  CalculateIdleState(threshold_,
+      base::Bind(&ExtensionIdlePollingTask::IdleStateCallback,
+                 base::Unretained(this)));
+}
+
+// static
+void ExtensionIdlePollingTask::CreateNewPollTask(int threshold, IdleState state,
+                                                 Profile* profile) {
+  if (ExtensionIdlePollingTask::poll_task_running_) return;
+
+  ExtensionIdlePollingTask::poll_task_running_ = true;
+  MessageLoop::current()->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&ExtensionIdlePollingTask::CheckIdleState, base::Unretained(
+          new ExtensionIdlePollingTask(threshold, state, profile))),
+      base::TimeDelta::FromSeconds(kIdlePollInterval));
+}
+
+
+const char* IdleStateToDescription(IdleState state) {
+  if (IDLE_STATE_ACTIVE == state)
+    return keys::kStateActive;
+  if (IDLE_STATE_IDLE == state)
+    return keys::kStateIdle;
+  return keys::kStateLocked;
+};
 
-  return threshold;
+// Helper function for reporting the idle state.  The lifetime of the object
+// returned is controlled by the caller.
+StringValue* CreateIdleValue(IdleState idle_state) {
+  StringValue* result = new StringValue(IdleStateToDescription(idle_state));
+  return result;
+}
+
+int CheckThresholdBounds(int timeout) {
+  if (timeout < kMinThreshold) return kMinThreshold;
+  if (timeout > kMaxThreshold) return kMaxThreshold;
+  return timeout;
 }
 
 }  // namespace
 
-namespace extensions {
+void ExtensionIdleEventRouter::OnIdleStateChange(Profile* profile,
+                                                 IdleState state) {
+  // Prepare the single argument of the current state.
+  scoped_ptr<ListValue> args(new ListValue());
+  args->Append(CreateIdleValue(state));
+
+  extensions::ExtensionSystem::Get(profile)->event_router()->
+      DispatchEventToRenderers(keys::kOnStateChanged, args.Pass(), profile,
+                               GURL(), extensions::EventFilteringInfo());
+}
 
-bool IdleQueryStateFunction::RunImpl() {
+bool ExtensionIdleQueryStateFunction::RunImpl() {
   int threshold;
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &threshold));
-  threshold = ClampThreshold(threshold);
+  threshold = CheckThresholdBounds(threshold);
 
-  IdleManagerFactory::GetForProfile(profile())->QueryState(
-      threshold,
-      base::Bind(&IdleQueryStateFunction::IdleStateCallback, this));
+  IdleState state = ExtensionIdleCache::CalculateIdleState(threshold);
+  if (state != IDLE_STATE_UNKNOWN) {
+    SetResult(CreateIdleValue(state));
+    SendResponse(true);
+    return true;
+  }
 
+  CalculateIdleState(threshold,
+      base::Bind(&ExtensionIdleQueryStateFunction::IdleStateCallback,
+                 this, threshold));
   // Don't send the response, it'll be sent by our callback
   return true;
 }
 
-void IdleQueryStateFunction::IdleStateCallback(IdleState state) {
-  SetResult(IdleManager::CreateIdleValue(state));
+void ExtensionIdleQueryStateFunction::IdleStateCallback(int threshold,
+                                                        IdleState state) {
+  // If our state is not active, make sure we're running a polling task to check
+  // for active state and report it when it changes to active.
+  if (state != IDLE_STATE_ACTIVE) {
+    ExtensionIdlePollingTask::CreateNewPollTask(threshold, state, profile_);
+  }
+
+  SetResult(CreateIdleValue(state));
+
+  ExtensionIdleCache::UpdateCache(threshold, state);
+
   SendResponse(true);
 }
 
-bool IdleSetDetectionIntervalFunction::RunImpl() {
-  int threshold;
-  EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &threshold));
-  threshold = ClampThreshold(threshold);
+ExtensionIdleCache::CacheData ExtensionIdleCache::cached_data =
+    {-1, -1, -1, -1};
 
-  IdleManagerFactory::GetForProfile(profile())->SetThreshold(extension_id(),
-                                                             threshold);
+IdleState ExtensionIdleCache::CalculateIdleState(int threshold) {
+  return CalculateState(threshold, base::Time::Now().ToDoubleT());
+}
 
-  return true;
+void ExtensionIdleCache::UpdateCache(int threshold, IdleState state) {
+  Update(threshold, state, base::Time::Now().ToDoubleT());
 }
 
-}  // namespace extensions
+IdleState ExtensionIdleCache::CalculateState(int threshold, double now) {
+  if (threshold < kMinThreshold)
+    return IDLE_STATE_UNKNOWN;
+  double threshold_moment = now - static_cast<double>(threshold);
+  double throttle_interval = static_cast<double>(kThrottleInterval);
+
+  // We test for IDEL_STATE_LOCKED first, because the result should be
+  // independent of the data for idle and active state. If last state was
+  // LOCKED and test for LOCKED is satisfied we should always return LOCKED.
+  if (cached_data.latest_locked > 0 &&
+      now - cached_data.latest_locked < throttle_interval)
+    return IDLE_STATE_LOCKED;
+
+  // If thershold moment is beyond the moment after whih we are certain we have
+  // been active, return active state. We allow kThrottleInterval error.
+  if (cached_data.latest_known_active > 0 &&
+      threshold_moment - cached_data.latest_known_active < throttle_interval)
+    return IDLE_STATE_ACTIVE;
+
+  // If total error that query interval has in respect to last recorded idle
+  // interval is less than kThrottleInterval, return IDLE state.
+  // query interval is the interval [now, now - threshold] and the error is
+  // defined as amount of query interval that is outside of idle interval.
+  double error_from_idle =
+      QueryErrorFromIdle(cached_data.idle_interval_start,
+          cached_data.idle_interval_end, threshold_moment, now);
+  if (cached_data.idle_interval_end > 0 &&
+      error_from_idle < throttle_interval)
+    return IDLE_STATE_IDLE;
+
+  return IDLE_STATE_UNKNOWN;
+}
+
+void ExtensionIdleCache::Update(int threshold, IdleState state, double now) {
+  if (threshold < kMinThreshold)
+    return;
+  double threshold_moment = now - static_cast<double>(threshold);
+  switch (state) {
+    case IDLE_STATE_IDLE:
+      if (threshold_moment > cached_data.idle_interval_end) {
+        // Cached and new interval don't overlap. We disregard the cached one.
+        cached_data.idle_interval_start = threshold_moment;
+      } else {
+        // Cached and new interval overlap, so we can combine them. We set
+        // the cached interval begining to less recent one.
+        cached_data.idle_interval_start =
+            std::min(cached_data.idle_interval_start, threshold_moment);
+      }
+      cached_data.idle_interval_end = now;
+      // Reset data for LOCKED state, since the last query result is not
+      // LOCKED.
+      cached_data.latest_locked = -1;
+      break;
+    case IDLE_STATE_ACTIVE:
+      if (threshold_moment > cached_data.latest_known_active)
+        cached_data.latest_known_active = threshold_moment;
+      // Reset data for LOCKED state, since the last query result is not
+      // LOCKED.
+      cached_data.latest_locked = -1;
+      break;
+    case IDLE_STATE_LOCKED:
+      if (threshold_moment > cached_data.latest_locked)
+        cached_data.latest_locked = now;
+      break;
+    default:
+      return;
+  }
+}
+
+int ExtensionIdleCache::get_min_threshold() {
+  return kMinThreshold;
+}
+
+double ExtensionIdleCache::get_throttle_interval() {
+  return static_cast<double>(kThrottleInterval);
+}
diff --git a/chrome/browser/extensions/api/idle/idle_api.h b/chrome/browser/extensions/api/idle/idle_api.h
index a2310fa..fd1f0e4 100644
--- a/chrome/browser/extensions/api/idle/idle_api.h
+++ b/chrome/browser/extensions/api/idle/idle_api.h
@@ -5,36 +5,84 @@
 #ifndef CHROME_BROWSER_EXTENSIONS_API_IDLE_IDLE_API_H_
 #define CHROME_BROWSER_EXTENSIONS_API_IDLE_IDLE_API_H_
 
-#include "chrome/browser/extensions/extension_function.h"
+#include "base/gtest_prod_util.h"
 #include "chrome/browser/idle.h"
+#include "chrome/browser/extensions/extension_function.h"
+
+class Profile;
+
+FORWARD_DECLARE_TEST(ExtensionIdleApiTest, CacheTest);
 
 namespace extensions {
 
+// Event router class for events related to the idle API.
+class ExtensionIdleEventRouter {
+ public:
+  static void OnIdleStateChange(Profile* profile,
+                                IdleState idleState);
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ExtensionIdleEventRouter);
+};
+
 // Implementation of the chrome.idle.queryState API.
-class IdleQueryStateFunction : public AsyncExtensionFunction {
+class ExtensionIdleQueryStateFunction : public AsyncExtensionFunction {
  public:
   DECLARE_EXTENSION_FUNCTION_NAME("idle.queryState")
 
  protected:
-  virtual ~IdleQueryStateFunction() {}
+  virtual ~ExtensionIdleQueryStateFunction() {}
 
   // ExtensionFunction:
   virtual bool RunImpl() OVERRIDE;
 
  private:
-  void IdleStateCallback(IdleState state);
+  void IdleStateCallback(int threshold, IdleState state);
 };
 
-// Implementation of the chrome.idle.setDetectionInterval API.
-class IdleSetDetectionIntervalFunction : public SyncExtensionFunction {
+// Class used for caching answers from CalculateIdleState.
+class ExtensionIdleCache {
  public:
-  DECLARE_EXTENSION_FUNCTION_NAME("idle.setDetectionInterval");
+  static IdleState CalculateIdleState(int threshold);
+  static void UpdateCache(int threshold, IdleState state);
 
- protected:
-  virtual ~IdleSetDetectionIntervalFunction() {}
+ private:
+  FRIEND_TEST_ALL_PREFIXES(::ExtensionIdleApiTest, CacheTest);
 
-  // ExtensionFunction:
-  virtual bool RunImpl() OVERRIDE;
+  struct CacheData {
+    // Latest moment in history after which we are certain that there was some
+    // activity. If we are querying for a  threshold beyond this moment, we know
+    // the result will be active.
+    double latest_known_active;
+    // [idle_interval_start, idle_interval_end] is the latest interval in
+    // history for which we are certain there was no activity.
+    double idle_interval_start;
+    double idle_interval_end;
+    // Set iff the last recored query result was IDLE_STATE_LOCKED. Equals the
+    // moment the result was recorded in cache.
+    double latest_locked;
+  };
+
+  // We assume moment is increasing with every call to one of these two methods.
+
+  // Tries to determine the idle state based on results of previous queries.
+  // |threshold| is time span in seconds from now we consider in calculating
+  // state.
+  // |moment| is the moment in time this method was called (should be equal to
+  // now, except in tests).
+  // Returns calculated state, or IDLE_STATE_UNKNOWN if the state could not be
+  // determined.
+  static IdleState CalculateState(int threshold, double moment);
+
+  // Updates cached data with the latest query result.
+  // |threshold| is threshold parameter of the query.
+  // |state| is result of the query.
+  // |moment| is moment in time this method is called.
+  static void Update(int threshold, IdleState state, double moment);
+
+  static int get_min_threshold();
+  static double get_throttle_interval();
+
+  static CacheData cached_data;
 };
 
 }  // namespace extensions
diff --git a/chrome/browser/extensions/api/idle/idle_api_unittest.cc b/chrome/browser/extensions/api/idle/idle_api_unittest.cc
index 82209c6..893596b 100644
--- a/chrome/browser/extensions/api/idle/idle_api_unittest.cc
+++ b/chrome/browser/extensions/api/idle/idle_api_unittest.cc
@@ -2,565 +2,122 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "chrome/browser/extensions/api/idle/idle_api.h"
-
-#include <limits.h>
-#include <string>
-
-#include "base/string_number_conversions.h"
-#include "chrome/browser/extensions/api/idle/idle_api_constants.h"
-#include "chrome/browser/extensions/api/idle/idle_manager.h"
-#include "chrome/browser/extensions/api/idle/idle_manager_factory.h"
-#include "chrome/browser/extensions/event_router.h"
-#include "chrome/browser/extensions/extension_function_test_utils.h"
-#include "chrome/common/chrome_notification_types.h"
-#include "chrome/common/extensions/extension.h"
-#include "chrome/common/extensions/extension_constants.h"
-#include "chrome/test/base/browser_with_test_window_test.h"
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-using ::testing::_;
-
-namespace utils = extension_function_test_utils;
-
-namespace extensions {
-
-namespace {
-
-class MockEventDelegate : public IdleManager::EventDelegate {
- public:
-  MockEventDelegate() {}
-  virtual ~MockEventDelegate() {}
-  MOCK_METHOD2(OnStateChanged, void(const std::string&, IdleState));
-  virtual void RegisterObserver(EventRouter::Observer* observer) {}
-  virtual void UnregisterObserver(EventRouter::Observer* observer) {}
-};
-
-class TestIdleProvider : public IdleManager::IdleTimeProvider {
- public:
-  TestIdleProvider();
-  virtual ~TestIdleProvider();
-  virtual void CalculateIdleState(int idle_threshold,
-                                  IdleCallback notify) OVERRIDE;
-  virtual void CalculateIdleTime(IdleTimeCallback notify) OVERRIDE;
-  virtual bool CheckIdleStateIsLocked() OVERRIDE;
-
-  void set_idle_time(int idle_time);
-  void set_locked(bool locked);
-
- private:
-  int idle_time_;
-  bool locked_;
-};
-
-TestIdleProvider::TestIdleProvider()
-    : idle_time_(0),
-      locked_(false) {
-}
-
-TestIdleProvider::~TestIdleProvider() {
-}
-
-void TestIdleProvider::CalculateIdleState(int idle_threshold,
-                                          IdleCallback notify) {
-  if (locked_) {
-    notify.Run(IDLE_STATE_LOCKED);
-  } else {
-    if (idle_time_ >= idle_threshold) {
-      notify.Run(IDLE_STATE_IDLE);
-    } else {
-      notify.Run(IDLE_STATE_ACTIVE);
-    }
-  }
-}
-
-void TestIdleProvider::CalculateIdleTime(IdleTimeCallback notify) {
-  notify.Run(idle_time_);
-}
-
-bool TestIdleProvider::CheckIdleStateIsLocked() {
-  return locked_;
-}
-
-void TestIdleProvider::set_idle_time(int idle_time) {
-  idle_time_ = idle_time;
-}
-
-void TestIdleProvider::set_locked(bool locked) {
-  locked_ = locked;
-}
-
-class ScopedListen {
- public:
-  ScopedListen(IdleManager* idle_manager, const std::string& extension_id);
-  ~ScopedListen();
-
- private:
-  IdleManager* idle_manager_;
-  const std::string extension_id_;
-};
-
-ScopedListen::ScopedListen(IdleManager* idle_manager,
-                           const std::string& extension_id)
-    : idle_manager_(idle_manager),
-      extension_id_(extension_id) {
-  const EventListenerInfo details(idle_api_constants::kOnStateChanged,
-                                  extension_id_);
-  idle_manager_->OnListenerAdded(details);
-}
-
-ScopedListen::~ScopedListen() {
-  const EventListenerInfo details(idle_api_constants::kOnStateChanged,
-                                  extension_id_);
-  idle_manager_->OnListenerRemoved(details);
-}
-
-ProfileKeyedService* IdleManagerTestFactory(Profile* profile) {
-  return new IdleManager(profile);
-}
-
-}  // namespace
-
-class IdleTest : public BrowserWithTestWindowTest {
- public:
-  virtual void SetUp() OVERRIDE;
-
- protected:
-  base::Value* RunFunctionWithExtension(
-      UIThreadExtensionFunction* function, const std::string& args);
-
-  void AddListener(const std::string& extension_id);
-  void RemoveListener(const std::string& extension_id);
-
-  IdleManager* idle_manager_;
-  TestIdleProvider* idle_provider_;
-  testing::StrictMock<MockEventDelegate>* event_delegate_;
-  scoped_refptr<extensions::Extension> extension_;
-};
-
-void IdleTest::SetUp() {
-  BrowserWithTestWindowTest::SetUp();
-
-  IdleManagerFactory::GetInstance()->SetTestingFactory(browser()->profile(),
-                                                       &IdleManagerTestFactory);
-  idle_manager_ = IdleManagerFactory::GetForProfile(browser()->profile());
-
-  extension_ = utils::CreateEmptyExtensionWithLocation(
-      extensions::Extension::LOAD);
-
-  idle_provider_ = new TestIdleProvider();
-  idle_manager_->SetIdleTimeProviderForTest(
-      scoped_ptr<IdleManager::IdleTimeProvider>(idle_provider_).Pass());
-  event_delegate_ = new testing::StrictMock<MockEventDelegate>();
-  idle_manager_->SetEventDelegateForTest(
-      scoped_ptr<IdleManager::EventDelegate>(event_delegate_).Pass());
-  idle_manager_->Init();
-}
-
-base::Value* IdleTest::RunFunctionWithExtension(
-    UIThreadExtensionFunction* function, const std::string& args) {
-  function->set_extension(extension_.get());
-  return utils::RunFunctionAndReturnSingleResult(function, args, browser());
-}
-
-// Verifies that "locked" takes priority over "active".
-TEST_F(IdleTest, QueryLockedActive) {
-  idle_provider_->set_locked(true);
-  idle_provider_->set_idle_time(0);
-
-  scoped_ptr<base::Value> result(RunFunctionWithExtension(
-      new IdleQueryStateFunction(),
-      "[60]"));
-
-  std::string idle_state;
-  ASSERT_TRUE(result->GetAsString(&idle_state));
-  EXPECT_EQ("locked", idle_state);
-}
-
-// Verifies that "locked" takes priority over "idle".
-TEST_F(IdleTest, QueryLockedIdle) {
-  idle_provider_->set_locked(true);
-  idle_provider_->set_idle_time(INT_MAX);
-
-  scoped_ptr<base::Value> result(RunFunctionWithExtension(
-      new IdleQueryStateFunction(),
-      "[60]"));
-
-  std::string idle_state;
-  ASSERT_TRUE(result->GetAsString(&idle_state));
-  EXPECT_EQ("locked", idle_state);
-}
-
-// Verifies that any amount of idle time less than the detection interval
-// translates to a state of "active".
-TEST_F(IdleTest, QueryActive) {
-  idle_provider_->set_locked(false);
-
-  for (int time = 0; time < 60; ++time) {
-    SCOPED_TRACE(time);
-    idle_provider_->set_idle_time(time);
-
-    scoped_ptr<base::Value> result(RunFunctionWithExtension(
-        new IdleQueryStateFunction(),
-        "[60]"));
-
-    std::string idle_state;
-    ASSERT_TRUE(result->GetAsString(&idle_state));
-    EXPECT_EQ("active", idle_state);
-  }
-}
-
-// Verifies that an idle time >= the detection interval returns the "idle"
-// state.
-TEST_F(IdleTest, QueryIdle) {
-  idle_provider_->set_locked(false);
-
-  for (int time = 80; time >= 60; --time) {
-    SCOPED_TRACE(time);
-    idle_provider_->set_idle_time(time);
-
-    scoped_ptr<base::Value> result(RunFunctionWithExtension(
-        new IdleQueryStateFunction(),
-        "[60]"));
-
-    std::string idle_state;
-    ASSERT_TRUE(result->GetAsString(&idle_state));
-    EXPECT_EQ("idle", idle_state);
-  }
-}
-
-// Verifies that requesting a detection interval < 15 has the same effect as
-// passing in 15.
-TEST_F(IdleTest, QueryMinThreshold) {
-  idle_provider_->set_locked(false);
-
-  for (int threshold = 0; threshold < 20; ++threshold) {
-    for (int time = 10; time < 60; ++time) {
-      SCOPED_TRACE(threshold);
-      SCOPED_TRACE(time);
-      idle_provider_->set_idle_time(time);
-
-      std::string args = "[" + base::IntToString(threshold) + "]";
-      scoped_ptr<base::Value> result(RunFunctionWithExtension(
-          new IdleQueryStateFunction(), args));
-
-      std::string idle_state;
-      ASSERT_TRUE(result->GetAsString(&idle_state));
-
-      int real_threshold = (threshold < 15) ? 15 : threshold;
-      const char* expected = (time < real_threshold) ? "active" : "idle";
-      EXPECT_EQ(expected, idle_state);
-    }
-  }
-}
-
-// Verifies that passing in a detection interval > 4 hours has the same effect
-// as passing in 4 hours.
-TEST_F(IdleTest, QueryMaxThreshold) {
-  idle_provider_->set_locked(false);
-
-  const int kFourHoursInSeconds = 4*60*60;
-
-  for (int threshold = kFourHoursInSeconds - 20;
-       threshold < (kFourHoursInSeconds + 20); ++threshold) {
-    for (int time = kFourHoursInSeconds - 30; time < kFourHoursInSeconds + 30;
-         ++time) {
-      SCOPED_TRACE(threshold);
-      SCOPED_TRACE(time);
-      idle_provider_->set_idle_time(time);
+#include <gtest/gtest.h>
 
-      std::string args = "[" + base::IntToString(threshold) + "]";
-      scoped_ptr<base::Value> result(RunFunctionWithExtension(
-          new IdleQueryStateFunction(), args));
-
-      std::string idle_state;
-      ASSERT_TRUE(result->GetAsString(&idle_state));
-
-      int real_threshold = (threshold > kFourHoursInSeconds) ?
-          kFourHoursInSeconds : threshold;
-      const char* expected = (time < real_threshold) ? "active" : "idle";
-      EXPECT_EQ(expected, idle_state);
-    }
-  }
-}
-
-// Verifies that transitioning from an active to idle state fires an "idle"
-// OnStateChanged event.
-TEST_F(IdleTest, ActiveToIdle) {
-  ScopedListen listen_test(idle_manager_, "test");
-
-  idle_provider_->set_locked(false);
-
-  for (int time = 0; time < 60; ++time) {
-    SCOPED_TRACE(time);
-    idle_provider_->set_idle_time(time);
-
-    idle_manager_->UpdateIdleState();
-  }
-
-  idle_provider_->set_idle_time(60);
-
-  EXPECT_CALL(*event_delegate_, OnStateChanged("test", IDLE_STATE_IDLE));
-  idle_manager_->UpdateIdleState();
-  testing::Mock::VerifyAndClearExpectations(event_delegate_);
-
-  for (int time = 61; time < 75; ++time) {
-    SCOPED_TRACE(time);
-    idle_provider_->set_idle_time(time);
-    idle_manager_->UpdateIdleState();
-  }
-}
-
-// Verifies that locking an active system generates a "locked" event.
-TEST_F(IdleTest, ActiveToLocked) {
-  ScopedListen listen_test(idle_manager_, "test");
-
-  idle_provider_->set_locked(true);
-  idle_provider_->set_idle_time(5);
-
-  EXPECT_CALL(*event_delegate_, OnStateChanged("test", IDLE_STATE_LOCKED));
-  idle_manager_->UpdateIdleState();
-}
-
-// Verifies that transitioning from an idle to active state generates an
-// "active" event.
-TEST_F(IdleTest, IdleToActive) {
-  ScopedListen listen_test(idle_manager_, "test");
-
-  idle_provider_->set_locked(false);
-  idle_provider_->set_idle_time(75);
-  EXPECT_CALL(*event_delegate_, OnStateChanged("test", IDLE_STATE_IDLE));
-  idle_manager_->UpdateIdleState();
-  testing::Mock::VerifyAndClearExpectations(event_delegate_);
-
-  idle_provider_->set_idle_time(0);
-  EXPECT_CALL(*event_delegate_, OnStateChanged("test", IDLE_STATE_ACTIVE));
-  idle_manager_->UpdateIdleState();
-}
-
-// Verifies that locking an idle system generates a "locked" event.
-TEST_F(IdleTest, IdleToLocked) {
-  ScopedListen listen_test(idle_manager_, "test");
-
-  idle_provider_->set_locked(false);
-  idle_provider_->set_idle_time(75);
-
-  EXPECT_CALL(*event_delegate_, OnStateChanged("test", IDLE_STATE_IDLE));
-  idle_manager_->UpdateIdleState();
-  testing::Mock::VerifyAndClearExpectations(event_delegate_);
-
-  idle_provider_->set_locked(true);
-  EXPECT_CALL(*event_delegate_, OnStateChanged("test", IDLE_STATE_LOCKED));
-  idle_manager_->UpdateIdleState();
-}
-
-// Verifies that unlocking an active system generates an "active" event.
-TEST_F(IdleTest, LockedToActive) {
-  ScopedListen listen_test(idle_manager_, "test");
-
-  idle_provider_->set_locked(true);
-  idle_provider_->set_idle_time(0);
-
-  EXPECT_CALL(*event_delegate_, OnStateChanged("test", IDLE_STATE_LOCKED));
-  idle_manager_->UpdateIdleState();
-
-  idle_provider_->set_locked(false);
-  idle_provider_->set_idle_time(5);
-  EXPECT_CALL(*event_delegate_, OnStateChanged("test", IDLE_STATE_ACTIVE));
-  idle_manager_->UpdateIdleState();
-}
-
-// Verifies that unlocking an inactive system generates an "idle" event.
-TEST_F(IdleTest, LockedToIdle) {
-  ScopedListen listen_test(idle_manager_, "test");
-
-  idle_provider_->set_locked(true);
-  idle_provider_->set_idle_time(75);
-  EXPECT_CALL(*event_delegate_, OnStateChanged("test", IDLE_STATE_LOCKED));
-  idle_manager_->UpdateIdleState();
-  testing::Mock::VerifyAndClearExpectations(event_delegate_);
-
-  idle_provider_->set_locked(false);
-  EXPECT_CALL(*event_delegate_, OnStateChanged("test", IDLE_STATE_IDLE));
-  idle_manager_->UpdateIdleState();
-}
-
-// Verifies that events are routed to extensions that have one or more listeners
-// in scope.
-TEST_F(IdleTest, MultipleExtensions) {
-  ScopedListen listen_1(idle_manager_, "1");
-  ScopedListen listen_2(idle_manager_, "2");
-
-  idle_provider_->set_locked(true);
-  EXPECT_CALL(*event_delegate_, OnStateChanged("1", IDLE_STATE_LOCKED));
-  EXPECT_CALL(*event_delegate_, OnStateChanged("2", IDLE_STATE_LOCKED));
-  idle_manager_->UpdateIdleState();
-  testing::Mock::VerifyAndClearExpectations(event_delegate_);
-
-  {
-    ScopedListen listen_2prime(idle_manager_, "2");
-    ScopedListen listen_3(idle_manager_, "3");
-    idle_provider_->set_locked(false);
-    EXPECT_CALL(*event_delegate_, OnStateChanged("1", IDLE_STATE_ACTIVE));
-    EXPECT_CALL(*event_delegate_, OnStateChanged("2", IDLE_STATE_ACTIVE));
-    EXPECT_CALL(*event_delegate_, OnStateChanged("3", IDLE_STATE_ACTIVE));
-    idle_manager_->UpdateIdleState();
-    testing::Mock::VerifyAndClearExpectations(event_delegate_);
-  }
-
-  idle_provider_->set_locked(true);
-  EXPECT_CALL(*event_delegate_, OnStateChanged("1", IDLE_STATE_LOCKED));
-  EXPECT_CALL(*event_delegate_, OnStateChanged("2", IDLE_STATE_LOCKED));
-  idle_manager_->UpdateIdleState();
-}
-
-// Verifies that setDetectionInterval changes the detection interval from the
-// default of 60 seconds, and that the call only affects a single extension's
-// IdleMonitor.
-TEST_F(IdleTest, SetDetectionInterval) {
-  ScopedListen listen_default(idle_manager_, "default");
-  ScopedListen listen_extension(idle_manager_, extension_->id());
-
-  scoped_ptr<base::Value> result45(RunFunctionWithExtension(
-      new IdleSetDetectionIntervalFunction(),
-      "[45]"));
-
-  idle_provider_->set_locked(false);
-  idle_provider_->set_idle_time(44);
-  idle_manager_->UpdateIdleState();
-
-  idle_provider_->set_idle_time(45);
-  EXPECT_CALL(*event_delegate_,
-              OnStateChanged(extension_->id(), IDLE_STATE_IDLE));
-  idle_manager_->UpdateIdleState();
-  // Verify that the expectation has been fulfilled before incrementing the
-  // time again.
-  testing::Mock::VerifyAndClearExpectations(event_delegate_);
-
-  idle_provider_->set_idle_time(60);
-  EXPECT_CALL(*event_delegate_, OnStateChanged("default", IDLE_STATE_IDLE));
-  idle_manager_->UpdateIdleState();
-}
-
-// Verifies that setting the detection interval before creating the listener
-// works correctly.
-TEST_F(IdleTest, SetDetectionIntervalBeforeListener) {
-  scoped_ptr<base::Value> result45(RunFunctionWithExtension(
-      new IdleSetDetectionIntervalFunction(),
-      "[45]"));
-
-  ScopedListen listen_extension(idle_manager_, extension_->id());
-
-  idle_provider_->set_locked(false);
-  idle_provider_->set_idle_time(44);
-  idle_manager_->UpdateIdleState();
-
-  idle_provider_->set_idle_time(45);
-  EXPECT_CALL(*event_delegate_,
-              OnStateChanged(extension_->id(), IDLE_STATE_IDLE));
-  idle_manager_->UpdateIdleState();
-}
-
-// Verifies that setting a detection interval above the maximum value results
-// in an interval of 4 hours.
-TEST_F(IdleTest, SetDetectionIntervalMaximum) {
-  ScopedListen listen_extension(idle_manager_, extension_->id());
-
-  scoped_ptr<base::Value> result(RunFunctionWithExtension(
-      new IdleSetDetectionIntervalFunction(),
-      "[18000]"));  // five hours in seconds
-
-  idle_provider_->set_locked(false);
-  idle_provider_->set_idle_time(4*60*60 - 1);
-  idle_manager_->UpdateIdleState();
-
-  idle_provider_->set_idle_time(4*60*60);
-  EXPECT_CALL(*event_delegate_,
-              OnStateChanged(extension_->id(), IDLE_STATE_IDLE));
-  idle_manager_->UpdateIdleState();
-}
-
-// Verifies that setting a detection interval below the minimum value results
-// in an interval of 15 seconds.
-TEST_F(IdleTest, SetDetectionIntervalMinimum) {
-  ScopedListen listen_extension(idle_manager_, extension_->id());
-
-  scoped_ptr<base::Value> result(RunFunctionWithExtension(
-      new IdleSetDetectionIntervalFunction(),
-      "[10]"));
-
-  idle_provider_->set_locked(false);
-  idle_provider_->set_idle_time(14);
-  idle_manager_->UpdateIdleState();
-
-  idle_provider_->set_idle_time(15);
-  EXPECT_CALL(*event_delegate_,
-              OnStateChanged(extension_->id(), IDLE_STATE_IDLE));
-  idle_manager_->UpdateIdleState();
-}
-
-// Verifies that an extension's detection interval is discarded when it unloads.
-TEST_F(IdleTest, UnloadCleanup) {
-  {
-    ScopedListen listen(idle_manager_, extension_->id());
-
-    scoped_ptr<base::Value> result45(RunFunctionWithExtension(
-        new IdleSetDetectionIntervalFunction(),
-        "[15]"));
-  }
-
-  // Listener count dropping to zero does not reset threshold.
-
-  {
-    ScopedListen listen(idle_manager_, extension_->id());
-    idle_provider_->set_idle_time(16);
-    EXPECT_CALL(*event_delegate_,
-                OnStateChanged(extension_->id(), IDLE_STATE_IDLE));
-    idle_manager_->UpdateIdleState();
-    testing::Mock::VerifyAndClearExpectations(event_delegate_);
-  }
-
-  // Threshold will reset after unload (and listen count == 0)
-  UnloadedExtensionInfo details(extension_,
-                                extension_misc::UNLOAD_REASON_UNINSTALL);
-  idle_manager_->Observe(
-      chrome::NOTIFICATION_EXTENSION_UNLOADED,
-      content::Source<Profile>(browser()->profile()),
-      content::Details<UnloadedExtensionInfo>(&details));
-
-  {
-    ScopedListen listen(idle_manager_, extension_->id());
-    idle_manager_->UpdateIdleState();
-    testing::Mock::VerifyAndClearExpectations(event_delegate_);
-
-    idle_provider_->set_idle_time(61);
-    EXPECT_CALL(*event_delegate_,
-                OnStateChanged(extension_->id(), IDLE_STATE_IDLE));
-    idle_manager_->UpdateIdleState();
-  }
-}
-
-// Verifies that unloading an extension with no listeners or threshold works.
-TEST_F(IdleTest, UnloadOnly) {
-  UnloadedExtensionInfo details(extension_,
-                                extension_misc::UNLOAD_REASON_UNINSTALL);
-  idle_manager_->Observe(
-      chrome::NOTIFICATION_EXTENSION_UNLOADED,
-      content::Source<Profile>(browser()->profile()),
-      content::Details<UnloadedExtensionInfo>(&details));
-}
+#include "chrome/browser/extensions/api/idle/idle_api.h"
 
-// Verifies that its ok for the unload notification to happen before all the
-// listener removals.
-TEST_F(IdleTest, UnloadWhileListening) {
-  ScopedListen listen(idle_manager_, extension_->id());
-  UnloadedExtensionInfo details(extension_,
-                                extension_misc::UNLOAD_REASON_UNINSTALL);
-  idle_manager_->Observe(
-      chrome::NOTIFICATION_EXTENSION_UNLOADED,
-      content::Source<Profile>(browser()->profile()),
-      content::Details<UnloadedExtensionInfo>(&details));
+using extensions::ExtensionIdleCache;
+
+TEST(ExtensionIdleApiTest, CacheTest) {
+  double throttle_interval = ExtensionIdleCache::get_throttle_interval();
+  int min_threshold = ExtensionIdleCache::get_min_threshold();
+  double now = 10 * min_threshold;
+
+  EXPECT_EQ(IDLE_STATE_UNKNOWN,
+            ExtensionIdleCache::CalculateState(min_threshold, now));
+
+  ExtensionIdleCache::Update(2 * min_threshold, IDLE_STATE_IDLE, now);
+
+  EXPECT_EQ(IDLE_STATE_IDLE,
+            ExtensionIdleCache::CalculateState(2 * min_threshold, now));
+  EXPECT_EQ(IDLE_STATE_IDLE,
+      ExtensionIdleCache::CalculateState(2 * min_threshold,
+                                         now + 0.9 * throttle_interval));
+  EXPECT_EQ(IDLE_STATE_IDLE,
+      ExtensionIdleCache::CalculateState(min_threshold,
+                                         now + 0.1 * throttle_interval));
+  // Threshold exeeds idle interval boundries.
+  EXPECT_EQ(IDLE_STATE_UNKNOWN,
+      ExtensionIdleCache::CalculateState(2 * min_threshold + 1,
+                                         now + 0.1 * throttle_interval));
+  // It has been more than throttle interval since last query.
+  EXPECT_EQ(IDLE_STATE_UNKNOWN,
+      ExtensionIdleCache::CalculateState(min_threshold,
+                                         now + 1.1 * throttle_interval));
+
+  now += 10 * min_threshold;
+  // Idle interval does not overlap with previous one.
+  ExtensionIdleCache::Update(5 * min_threshold, IDLE_STATE_IDLE, now);
+  EXPECT_EQ(IDLE_STATE_UNKNOWN,
+            ExtensionIdleCache::CalculateState(7 * min_threshold, now));
+
+  now += min_threshold;
+  // Idle interval overlaps with previous one.
+  ExtensionIdleCache::Update(2 * min_threshold, IDLE_STATE_IDLE, now);
+  // Threshold exeeds last idle interval boundaries, but does not exeed union of
+  // two last (overlaping) idle intervals.
+  EXPECT_EQ(IDLE_STATE_IDLE,
+            ExtensionIdleCache::CalculateState(4 * min_threshold, now));
+
+  now += 0.2 * throttle_interval;
+  ExtensionIdleCache::Update(8 * min_threshold, IDLE_STATE_ACTIVE, now);
+  EXPECT_EQ(IDLE_STATE_IDLE,
+      ExtensionIdleCache::CalculateState(4 * min_threshold,
+                                         now + 0.3 * throttle_interval));
+
+  // If both idle and active conditions are satisfied, return ACTIVE (because
+  // obviously ACTIVE was reported after last idle interval).
+  ExtensionIdleCache::Update(3 * min_threshold, IDLE_STATE_ACTIVE, now);
+  EXPECT_EQ(IDLE_STATE_ACTIVE,
+      ExtensionIdleCache::CalculateState(4 * min_threshold,
+                                         now + 0.3 * throttle_interval));
+
+  now += 10 * min_threshold;
+  ExtensionIdleCache::Update(8 * min_threshold, IDLE_STATE_ACTIVE, now);
+  // Threshold does not exeed last active state, but the error is within
+  // throttle interval.
+  EXPECT_EQ(IDLE_STATE_ACTIVE,
+      ExtensionIdleCache::CalculateState(8 * min_threshold,
+                                         now + 0.3 * throttle_interval));
+  // The error is not within throttle interval.
+  EXPECT_EQ(IDLE_STATE_UNKNOWN,
+      ExtensionIdleCache::CalculateState(8 * min_threshold,
+                                         now + 1.1 * throttle_interval));
+
+  // We report LOCKED iff it was last reported state was LOCKED and  it has
+  // been less than throttle_interval since last query.
+  now += 10 * min_threshold;
+  ExtensionIdleCache::Update(4 * min_threshold, IDLE_STATE_LOCKED, now);
+  EXPECT_EQ(IDLE_STATE_LOCKED,
+      ExtensionIdleCache::CalculateState(2 * min_threshold,
+                                         now + 0.3 * throttle_interval));
+  // More than throttle_interval since last query.
+  EXPECT_EQ(IDLE_STATE_UNKNOWN,
+      ExtensionIdleCache::CalculateState(2 * min_threshold,
+                                         now + 1.1 * throttle_interval));
+
+  now += 0.2 * throttle_interval;
+  ExtensionIdleCache::Update(4 * min_threshold, IDLE_STATE_ACTIVE, now);
+  // Last reported query was ACTIVE.
+  EXPECT_EQ(IDLE_STATE_UNKNOWN,
+      ExtensionIdleCache::CalculateState(2 * min_threshold,
+                                         now + 0.3 * throttle_interval));
+
+  now += 0.2 * throttle_interval;
+  ExtensionIdleCache::Update(2 * min_threshold, IDLE_STATE_LOCKED, now);
+  EXPECT_EQ(IDLE_STATE_LOCKED,
+      ExtensionIdleCache::CalculateState(5 * min_threshold,
+                                         now + 0.3 * throttle_interval));
+
+  now += 10 * min_threshold;
+  ExtensionIdleCache::Update(4 * min_threshold, IDLE_STATE_LOCKED, now);
+
+  now += 0.2 * throttle_interval;
+  ExtensionIdleCache::Update(2 * min_threshold, IDLE_STATE_IDLE, now);
+
+  // Last reported state was IDLE.
+  EXPECT_EQ(IDLE_STATE_UNKNOWN,
+      ExtensionIdleCache::CalculateState(3 * min_threshold,
+                                         now + 0.3 * throttle_interval));
+
+  now += min_threshold;
+  ExtensionIdleCache::Update(2 * min_threshold, IDLE_STATE_LOCKED, now);
+
+  now += 0.2 * throttle_interval;
+  ExtensionIdleCache::Update(4 * min_threshold, IDLE_STATE_ACTIVE, now);
+
+  // Last reported state was ACTIVE.
+  EXPECT_EQ(IDLE_STATE_ACTIVE,
+      ExtensionIdleCache::CalculateState(6 * min_threshold,
+                                         now + 0.3 * throttle_interval));
 }
-
-}  // extensions
diff --git a/chrome/browser/extensions/api/idle/idle_manager.cc b/chrome/browser/extensions/api/idle/idle_manager.cc
deleted file mode 100644
index 5931348..0000000
--- a/chrome/browser/extensions/api/idle/idle_manager.cc
+++ /dev/null
@@ -1,271 +0,0 @@
-// Copyright (c) 2012 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/extensions/api/idle/idle_manager.h"
-
-#include <utility>
-
-#include "base/stl_util.h"
-#include "chrome/browser/extensions/api/idle/idle_api_constants.h"
-#include "chrome/browser/extensions/event_router.h"
-#include "chrome/browser/extensions/extension_system.h"
-#include "chrome/browser/profiles/profile.h"
-#include "chrome/common/chrome_notification_types.h"
-#include "chrome/common/extensions/extension.h"
-#include "chrome/common/extensions/extension_constants.h"
-
-namespace keys = extensions::idle_api_constants;
-
-namespace extensions {
-
-namespace {
-
-const int kDefaultIdleThreshold = 60;
-const int kPollInterval = 1;
-
-class DefaultEventDelegate : public IdleManager::EventDelegate {
- public:
-  explicit DefaultEventDelegate(Profile* profile);
-  virtual ~DefaultEventDelegate();
-
-  virtual void OnStateChanged(const std::string& extension_id,
-                              IdleState new_state) OVERRIDE;
-  virtual void RegisterObserver(EventRouter::Observer* observer) OVERRIDE;
-  virtual void UnregisterObserver(EventRouter::Observer* observer) OVERRIDE;
-
- private:
-  Profile* profile_;
-};
-
-DefaultEventDelegate::DefaultEventDelegate(Profile* profile)
-    : profile_(profile) {
-}
-
-DefaultEventDelegate::~DefaultEventDelegate() {
-}
-
-void DefaultEventDelegate::OnStateChanged(const std::string& extension_id,
-                                          IdleState new_state) {
-  scoped_ptr<ListValue> args(new ListValue());
-  args->Append(IdleManager::CreateIdleValue(new_state));
-  ExtensionSystem::Get(profile_)->event_router()->DispatchEventToExtension(
-      extension_id, keys::kOnStateChanged, args.Pass(), profile_, GURL());
-}
-
-void DefaultEventDelegate::RegisterObserver(
-    EventRouter::Observer* observer) {
-  ExtensionSystem::Get(profile_)->event_router()->RegisterObserver(
-      observer, idle_api_constants::kOnStateChanged);
-}
-
-void DefaultEventDelegate::UnregisterObserver(EventRouter::Observer* observer) {
-  ExtensionSystem::Get(profile_)->event_router()->UnregisterObserver(observer);
-}
-
-
-class DefaultIdleProvider : public IdleManager::IdleTimeProvider {
- public:
-  DefaultIdleProvider();
-  virtual ~DefaultIdleProvider();
-
-  virtual void CalculateIdleState(int idle_threshold,
-                                  IdleCallback notify) OVERRIDE;
-  virtual void CalculateIdleTime(IdleTimeCallback notify) OVERRIDE;
-  virtual bool CheckIdleStateIsLocked() OVERRIDE;
-};
-
-DefaultIdleProvider::DefaultIdleProvider() {
-}
-
-DefaultIdleProvider::~DefaultIdleProvider() {
-}
-
-void DefaultIdleProvider::CalculateIdleState(int idle_threshold,
-                                             IdleCallback notify) {
-  ::CalculateIdleState(idle_threshold, notify);
-}
-
-void DefaultIdleProvider::CalculateIdleTime(IdleTimeCallback notify) {
-  ::CalculateIdleTime(notify);
-}
-
-bool DefaultIdleProvider::CheckIdleStateIsLocked() {
-  return ::CheckIdleStateIsLocked();
-}
-
-IdleState IdleTimeToIdleState(bool locked, int idle_time, int idle_threshold) {
-  IdleState state;
-
-  if (locked) {
-    state = IDLE_STATE_LOCKED;
-  } else if (idle_time >= idle_threshold) {
-    state = IDLE_STATE_IDLE;
-  } else {
-    state = IDLE_STATE_ACTIVE;
-  }
-  return state;
-}
-
-}  // namespace
-
-IdleMonitor::IdleMonitor(IdleState initial_state)
-    : last_state(initial_state),
-      listeners(0),
-      threshold(kDefaultIdleThreshold) {
-}
-
-IdleManager::IdleManager(Profile* profile)
-    : profile_(profile),
-      last_state_(IDLE_STATE_ACTIVE),
-      weak_factory_(this),
-      idle_time_provider_(new DefaultIdleProvider()),
-      event_delegate_(new DefaultEventDelegate(profile)) {
-}
-
-IdleManager::~IdleManager() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  event_delegate_->UnregisterObserver(this);
-}
-
-void IdleManager::Init() {
-  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED,
-                 content::Source<Profile>(profile_->GetOriginalProfile()));
-  event_delegate_->RegisterObserver(this);
-}
-
-void IdleManager::Observe(int type,
-                          const content::NotificationSource& source,
-                          const content::NotificationDetails& details) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(type == chrome::NOTIFICATION_EXTENSION_UNLOADED);
-
-  const Extension* extension =
-      content::Details<extensions::UnloadedExtensionInfo>(details)->extension;
-  monitors_.erase(extension->id());
-}
-
-void IdleManager::OnListenerAdded(const EventListenerInfo& details) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-
-  ++GetMonitor(details.extension_id)->listeners;
-  StartPolling();
-}
-
-void IdleManager::OnListenerRemoved(const EventListenerInfo& details) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-
-  // During unload the monitor could already have been deleted. No need to do
-  // anything in that case.
-  MonitorMap::iterator it = monitors_.find(details.extension_id);
-  if (it != monitors_.end()) {
-    DCHECK_GT(it->second.listeners, 0);
-    --it->second.listeners;
-  }
-}
-
-void IdleManager::QueryState(int threshold, QueryStateCallback notify) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  idle_time_provider_->CalculateIdleState(threshold, notify);
-}
-
-void IdleManager::SetThreshold(const std::string& extension_id,
-                               int threshold) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  GetMonitor(extension_id)->threshold = threshold;
-}
-
-// static
-StringValue* IdleManager::CreateIdleValue(IdleState idle_state) {
-  const char* description;
-
-  if (idle_state == IDLE_STATE_ACTIVE) {
-    description = keys::kStateActive;
-  } else if (idle_state == IDLE_STATE_IDLE) {
-    description = keys::kStateIdle;
-  } else {
-    description = keys::kStateLocked;
-  }
-
-  return new StringValue(description);
-}
-
-void IdleManager::SetEventDelegateForTest(
-    scoped_ptr<EventDelegate> event_delegate) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  event_delegate_ = event_delegate.Pass();
-}
-
-void IdleManager::SetIdleTimeProviderForTest(
-    scoped_ptr<IdleTimeProvider> idle_time_provider) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  idle_time_provider_ = idle_time_provider.Pass();
-}
-
-IdleMonitor* IdleManager::GetMonitor(const std::string& extension_id) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  MonitorMap::iterator it = monitors_.find(extension_id);
-
-  if (it == monitors_.end()) {
-    it = monitors_.insert(std::make_pair(extension_id,
-                                         IdleMonitor(last_state_))).first;
-  }
-  return &it->second;
-}
-
-void IdleManager::StartPolling() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  if (!poll_timer_.IsRunning()) {
-    poll_timer_.Start(FROM_HERE,
-                      base::TimeDelta::FromSeconds(kPollInterval),
-                      this,
-                      &IdleManager::UpdateIdleState);
-  }
-}
-
-void IdleManager::StopPolling() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  poll_timer_.Stop();
-}
-
-void IdleManager::UpdateIdleState() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  idle_time_provider_->CalculateIdleTime(
-      base::Bind(
-          &IdleManager::UpdateIdleStateCallback,
-          weak_factory_.GetWeakPtr()));
-}
-
-void IdleManager::UpdateIdleStateCallback(int idle_time) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  bool locked = idle_time_provider_->CheckIdleStateIsLocked();
-  int listener_count = 0;
-
-  // Remember this state for initializing new event listeners.
-  last_state_ = IdleTimeToIdleState(locked,
-                                    idle_time,
-                                    kDefaultIdleThreshold);
-
-  for (MonitorMap::iterator it = monitors_.begin();
-       it != monitors_.end(); ++it) {
-    if (it->second.listeners < 1)
-      continue;
-
-    ++listener_count;
-
-    IdleState new_state = IdleTimeToIdleState(locked,
-                                              idle_time,
-                                              it->second.threshold);
-
-    if (new_state != it->second.last_state) {
-      it->second.last_state = new_state;
-      event_delegate_->OnStateChanged(it->first, new_state);
-    }
-  }
-
-  if (listener_count == 0) {
-    StopPolling();
-  }
-}
-
-}  // namespace extensions
diff --git a/chrome/browser/extensions/api/idle/idle_manager.h b/chrome/browser/extensions/api/idle/idle_manager.h
deleted file mode 100644
index e54df77..0000000
--- a/chrome/browser/extensions/api/idle/idle_manager.h
+++ /dev/null
@@ -1,136 +0,0 @@
-// Copyright (c) 2012 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_EXTENSIONS_API_IDLE_IDLE_MANAGER_H_
-#define CHROME_BROWSER_EXTENSIONS_API_IDLE_IDLE_MANAGER_H_
-
-#include <map>
-#include <string>
-
-#include "base/callback_forward.h"
-#include "base/gtest_prod_util.h"
-#include "base/memory/weak_ptr.h"
-#include "base/threading/thread_checker.h"
-#include "base/timer.h"
-#include "chrome/browser/extensions/event_router.h"
-#include "chrome/browser/idle.h"
-#include "chrome/browser/profiles/profile_keyed_service.h"
-#include "content/public/browser/notification_observer.h"
-#include "content/public/browser/notification_registrar.h"
-
-namespace base {
-class StringValue;
-}  // namespace base
-
-class Profile;
-
-namespace extensions {
-
-typedef base::Callback<void(IdleState)> QueryStateCallback;
-
-struct IdleMonitor {
-  explicit IdleMonitor(IdleState initial_state);
-
-  IdleState last_state;
-  int listeners;
-  int threshold;
-};
-
-class IdleManager : public content::NotificationObserver,
-                    public EventRouter::Observer,
-                    public ProfileKeyedService {
- public:
-  class IdleTimeProvider {
-   public:
-    IdleTimeProvider() {}
-    virtual ~IdleTimeProvider() {}
-    virtual void CalculateIdleState(int idle_threshold,
-                                    IdleCallback notify) = 0;
-    virtual void CalculateIdleTime(IdleTimeCallback notify) = 0;
-    virtual bool CheckIdleStateIsLocked() = 0;
-
-   private:
-    DISALLOW_COPY_AND_ASSIGN(IdleTimeProvider);
-  };
-
-  class EventDelegate {
-   public:
-    EventDelegate() {}
-    virtual ~EventDelegate() {}
-    virtual void OnStateChanged(const std::string& extension_id,
-                                IdleState new_state) = 0;
-    virtual void RegisterObserver(EventRouter::Observer* observer) = 0;
-    virtual void UnregisterObserver(EventRouter::Observer* observer) = 0;
-
-   private:
-    DISALLOW_COPY_AND_ASSIGN(EventDelegate);
-  };
-
-  explicit IdleManager(Profile* profile);
-  virtual ~IdleManager();
-
-  void Init();
-
-  // content::NotificationDelegate implementation.
-  virtual void Observe(int type,
-                       const content::NotificationSource& source,
-                       const content::NotificationDetails& details) OVERRIDE;
-
-  // EventRouter::Observer implementation.
-  virtual void OnListenerAdded(const EventListenerInfo& details) OVERRIDE;
-  virtual void OnListenerRemoved(const EventListenerInfo& details) OVERRIDE;
-
-  void QueryState(int threshold, QueryStateCallback notify);
-  void SetThreshold(const std::string& extension_id, int threshold);
-  static base::StringValue* CreateIdleValue(IdleState idle_state);
-
-  // Override default event class. Callee assumes ownership. Used for testing.
-  void SetEventDelegateForTest(scoped_ptr<EventDelegate> event_delegate);
-
-  // Override default idle time calculations. Callee assumes ownership. Used
-  // for testing.
-  void SetIdleTimeProviderForTest(scoped_ptr<IdleTimeProvider> idle_provider);
-
- private:
-  FRIEND_TEST_ALL_PREFIXES(IdleTest, ActiveToIdle);
-  FRIEND_TEST_ALL_PREFIXES(IdleTest, ActiveToLocked);
-  FRIEND_TEST_ALL_PREFIXES(IdleTest, IdleToActive);
-  FRIEND_TEST_ALL_PREFIXES(IdleTest, IdleToLocked);
-  FRIEND_TEST_ALL_PREFIXES(IdleTest, LockedToActive);
-  FRIEND_TEST_ALL_PREFIXES(IdleTest, LockedToIdle);
-  FRIEND_TEST_ALL_PREFIXES(IdleTest, MultipleExtensions);
-  FRIEND_TEST_ALL_PREFIXES(IdleTest, SetDetectionInterval);
-  FRIEND_TEST_ALL_PREFIXES(IdleTest, SetDetectionIntervalBeforeListener);
-  FRIEND_TEST_ALL_PREFIXES(IdleTest, SetDetectionIntervalMaximum);
-  FRIEND_TEST_ALL_PREFIXES(IdleTest, SetDetectionIntervalMinimum);
-  FRIEND_TEST_ALL_PREFIXES(IdleTest, UnloadCleanup);
-
-  typedef std::map<const std::string, IdleMonitor> MonitorMap;
-
-  IdleMonitor* GetMonitor(const std::string& extension_id);
-  void StartPolling();
-  void StopPolling();
-  void UpdateIdleState();
-  void UpdateIdleStateCallback(int idle_time);
-
-  Profile* profile_;
-
-  IdleState last_state_;
-  MonitorMap monitors_;
-
-  base::RepeatingTimer<IdleManager> poll_timer_;
-  base::WeakPtrFactory<IdleManager> weak_factory_;
-  content::NotificationRegistrar registrar_;
-
-  scoped_ptr<IdleTimeProvider> idle_time_provider_;
-  scoped_ptr<EventDelegate> event_delegate_;
-
-  base::ThreadChecker thread_checker_;
-
-  DISALLOW_COPY_AND_ASSIGN(IdleManager);
-};
-
-}  // namespace extensions
-
-#endif  // CHROME_BROWSER_EXTENSIONS_API_IDLE_IDLE_MANAGER_H_
diff --git a/chrome/browser/extensions/api/idle/idle_manager_factory.cc b/chrome/browser/extensions/api/idle/idle_manager_factory.cc
deleted file mode 100644
index 84df8cb..0000000
--- a/chrome/browser/extensions/api/idle/idle_manager_factory.cc
+++ /dev/null
@@ -1,53 +0,0 @@
-// Copyright (c) 2012 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/extensions/api/idle/idle_manager_factory.h"
-
-#include "chrome/browser/extensions/api/idle/idle_manager.h"
-#include "chrome/browser/extensions/extension_system_factory.h"
-#include "chrome/browser/profiles/profile_dependency_manager.h"
-
-namespace extensions {
-
-// static
-IdleManager* IdleManagerFactory::GetForProfile(
-    Profile* profile) {
-  return static_cast<IdleManager*>(
-      GetInstance()->GetServiceForProfile(profile, true));
-}
-
-// static
-IdleManagerFactory* IdleManagerFactory::GetInstance() {
-  return Singleton<IdleManagerFactory>::get();
-}
-
-IdleManagerFactory::IdleManagerFactory()
-    : ProfileKeyedServiceFactory("IdleManager",
-                                 ProfileDependencyManager::GetInstance()) {
-  DependsOn(ExtensionSystemFactory::GetInstance());
-}
-
-IdleManagerFactory::~IdleManagerFactory() {
-}
-
-ProfileKeyedService* IdleManagerFactory::BuildServiceInstanceFor(
-    Profile* profile) const {
-  IdleManager* idle_manager = new IdleManager(profile);
-  idle_manager->Init();
-  return idle_manager;
-}
-
-bool IdleManagerFactory::ServiceRedirectedInIncognito() const {
-  return true;
-}
-
-bool IdleManagerFactory::ServiceIsCreatedWithProfile() const {
-  return true;
-}
-
-bool IdleManagerFactory::ServiceIsNULLWhileTesting() const {
-  return true;
-}
-
-}  // namespace extensions
diff --git a/chrome/browser/extensions/api/idle/idle_manager_factory.h b/chrome/browser/extensions/api/idle/idle_manager_factory.h
deleted file mode 100644
index 8f902dc..0000000
--- a/chrome/browser/extensions/api/idle/idle_manager_factory.h
+++ /dev/null
@@ -1,36 +0,0 @@
-// Copyright (c) 2012 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_EXTENSIONS_API_IDLE_IDLE_MANAGER_FACTORY_H__
-#define CHROME_BROWSER_EXTENSIONS_API_IDLE_IDLE_MANAGER_FACTORY_H__
-
-#include "base/memory/singleton.h"
-#include "chrome/browser/profiles/profile_keyed_service_factory.h"
-
-namespace extensions {
-class IdleManager;
-
-class IdleManagerFactory : public ProfileKeyedServiceFactory {
- public:
-  static IdleManager* GetForProfile(Profile* profile);
-
-  static IdleManagerFactory* GetInstance();
-
- private:
-  friend struct DefaultSingletonTraits<IdleManagerFactory>;
-
-  IdleManagerFactory();
-  virtual ~IdleManagerFactory();
-
-  // ProfileKeyedBaseFactory implementation.
-  virtual ProfileKeyedService* BuildServiceInstanceFor(
-      Profile* profile) const OVERRIDE;
-  virtual bool ServiceRedirectedInIncognito() const OVERRIDE;
-  virtual bool ServiceIsCreatedWithProfile() const OVERRIDE;
-  virtual bool ServiceIsNULLWhileTesting() const OVERRIDE;
-};
-
-}  // namespace extensions
-
-#endif  // CHROME_BROWSER_EXTENSIONS_API_IDLE_IDLE_MANAGER_FACTORY_H__
diff --git a/chrome/browser/extensions/extension_function_registry.cc b/chrome/browser/extensions/extension_function_registry.cc
index 53aedc8..21b9030 100644
--- a/chrome/browser/extensions/extension_function_registry.cc
+++ b/chrome/browser/extensions/extension_function_registry.cc
@@ -201,8 +201,7 @@ void ExtensionFunctionRegistry::ResetFunctions() {
   RegisterFunction<SearchHistoryFunction>();
 
   // Idle
-  RegisterFunction<extensions::IdleQueryStateFunction>();
-  RegisterFunction<extensions::IdleSetDetectionIntervalFunction>();
+  RegisterFunction<extensions::ExtensionIdleQueryStateFunction>();
 
   // I18N.
   RegisterFunction<GetAcceptLanguagesFunction>();
diff --git a/chrome/browser/idle.cc b/chrome/browser/idle.cc
deleted file mode 100644
index 7a19943..0000000
--- a/chrome/browser/idle.cc
+++ /dev/null
@@ -1,31 +0,0 @@
-// Copyright (c) 2011 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/idle.h"
-
-#include "base/bind.h"
-
-namespace {
-
-void CalculateIdleStateCallback(int idle_threshold,
-                                IdleCallback notify,
-                                int idle_time) {
-  if (idle_time >= idle_threshold)
-    notify.Run(IDLE_STATE_IDLE);
-  else
-    notify.Run(IDLE_STATE_ACTIVE);
-}
-
-}  // namespace
-
-void CalculateIdleState(int idle_threshold, IdleCallback notify) {
-  if (CheckIdleStateIsLocked()) {
-    notify.Run(IDLE_STATE_LOCKED);
-    return;
-  }
-
-  CalculateIdleTime(base::Bind(&CalculateIdleStateCallback,
-                               idle_threshold,
-                               notify));
-}
diff --git a/chrome/browser/idle.h b/chrome/browser/idle.h
index 7b78cd9..df6abd7 100644
--- a/chrome/browser/idle.h
+++ b/chrome/browser/idle.h
@@ -23,13 +23,9 @@ void StopIdleMonitor();
 #endif
 
 typedef base::Callback<void(IdleState)> IdleCallback;
-typedef base::Callback<void(int)> IdleTimeCallback;
 
 // Calculate the Idle state and notify the callback.
-void CalculateIdleState(int idle_threshold, IdleCallback notify);
-
-// Calculate Idle time in seconds and notify the callback
-void CalculateIdleTime(IdleTimeCallback notify);
+void CalculateIdleState(unsigned int idle_threshold, IdleCallback notify);
 
 // Checks synchronously if Idle state is IDLE_STATE_LOCKED.
 bool CheckIdleStateIsLocked();
diff --git a/chrome/browser/idle_android.cc b/chrome/browser/idle_android.cc
index 9d4fa2c..7cf1969 100644
--- a/chrome/browser/idle_android.cc
+++ b/chrome/browser/idle_android.cc
@@ -10,12 +10,7 @@
 // constrained devices such as Android we'll often get completely killed if
 // Chrome isn't active anyway.
 // TODO(yfriedman): Tracking in bug: 114481
-void CalculateIdleTime(IdleTimeCallback notify) {
+void CalculateIdleState(unsigned int idle_threshold, IdleCallback notify) {
   NOTIMPLEMENTED();
-  notify.Run(0);
-}
-
-bool CheckIdleStateIsLocked() {
-  NOTIMPLEMENTED();
-  return false;
+  notify.Run(IDLE_STATE_ACTIVE);
 }
diff --git a/chrome/browser/idle_chromeos.cc b/chrome/browser/idle_chromeos.cc
index 32b7fdd..d8f2f08 100644
--- a/chrome/browser/idle_chromeos.cc
+++ b/chrome/browser/idle_chromeos.cc
@@ -4,25 +4,27 @@
 
 #include "chrome/browser/idle.h"
 
-#include <limits.h>
-
 #include "base/bind.h"
 #include "base/callback.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/power_manager_client.h"
 
-void CalculateIdleTimeNotifier(IdleTimeCallback notify,
-                               int64_t idle_time_s) {
-  if (idle_time_s > INT_MAX) {
-    // Just in case you are idle for > 100 years.
-    idle_time_s = INT_MAX;
+void CalculateIdleStateNotifier(unsigned int idle_treshold,
+                                IdleCallback notify,
+                                int64_t idle_time_s) {
+  if (idle_time_s >= (int64_t)idle_treshold) {
+    notify.Run(IDLE_STATE_IDLE);
+  } else if (idle_time_s < 0) {
+    notify.Run(IDLE_STATE_UNKNOWN);
+  } else {
+    notify.Run(IDLE_STATE_ACTIVE);
   }
-  notify.Run(static_cast<int>(idle_time_s));
 }
 
-void CalculateIdleTime(IdleTimeCallback notify) {
+void CalculateIdleState(unsigned int idle_threshold, IdleCallback notify) {
   chromeos::DBusThreadManager::Get()->GetPowerManagerClient()->
-      CalculateIdleTime(base::Bind(&CalculateIdleTimeNotifier, notify));
+      CalculateIdleTime(base::Bind(&CalculateIdleStateNotifier, idle_threshold,
+                                   notify));
 }
 
 bool CheckIdleStateIsLocked() {
diff --git a/chrome/browser/idle_linux.cc b/chrome/browser/idle_linux.cc
index 023a1b2..045a47d 100644
--- a/chrome/browser/idle_linux.cc
+++ b/chrome/browser/idle_linux.cc
@@ -11,9 +11,17 @@
 #include "chrome/browser/screensaver_window_finder_gtk.h"
 #endif
 
-void CalculateIdleTime(IdleTimeCallback notify) {
+void CalculateIdleState(unsigned int idle_threshold, IdleCallback notify) {
+  if (CheckIdleStateIsLocked()) {
+    notify.Run(IDLE_STATE_LOCKED);
+    return;
+  }
   chrome::IdleQueryLinux idle_query;
-  notify.Run(idle_query.IdleTime());
+  unsigned int idle_time = idle_query.IdleTime();
+  if (idle_time >= idle_threshold)
+    notify.Run(IDLE_STATE_IDLE);
+  else
+    notify.Run(IDLE_STATE_ACTIVE);
 }
 
 bool CheckIdleStateIsLocked() {
diff --git a/chrome/browser/idle_mac.mm b/chrome/browser/idle_mac.mm
index d13da03..8547ff5 100644
--- a/chrome/browser/idle_mac.mm
+++ b/chrome/browser/idle_mac.mm
@@ -50,7 +50,7 @@
 }
 
 - (void)dealloc {
-  [[NSDistributedNotificationCenter defaultCenter] removeObserver:self];
+  [[NSDistributedNotificationCenter defaultCenter] removeObject:self];
   [super dealloc];
 }
 
@@ -84,11 +84,19 @@ void StopIdleMonitor() {
   g_screenMonitor = nil;
 }
 
-void CalculateIdleTime(IdleTimeCallback notify) {
+void CalculateIdleState(unsigned int idle_threshold, IdleCallback notify) {
+  if (CheckIdleStateIsLocked()) {
+    notify.Run(IDLE_STATE_LOCKED);
+    return;
+  }
+
   CFTimeInterval idle_time = CGEventSourceSecondsSinceLastEventType(
       kCGEventSourceStateCombinedSessionState,
       kCGAnyInputEventType);
-  notify.Run(static_cast<int>(idle_time));
+  if (idle_time >= idle_threshold)
+    notify.Run(IDLE_STATE_IDLE);
+  else
+    notify.Run(IDLE_STATE_ACTIVE);
 }
 
 bool CheckIdleStateIsLocked() {
diff --git a/chrome/browser/idle_win.cc b/chrome/browser/idle_win.cc
index 3c6c7d5..784bee7 100644
--- a/chrome/browser/idle_win.cc
+++ b/chrome/browser/idle_win.cc
@@ -7,9 +7,15 @@
 #include <limits.h>
 #include <windows.h>
 
-namespace {
+static bool IsScreensaverRunning();
+static bool IsWorkstationLocked();
+
+void CalculateIdleState(unsigned int idle_threshold, IdleCallback notify) {
+  if (CheckIdleStateIsLocked()) {
+    notify.Run(IDLE_STATE_LOCKED);
+    return;
+  }
 
-DWORD CalculateIdleTimeInternal() {
   LASTINPUTINFO last_input_info = {0};
   last_input_info.cbSize = sizeof(LASTINPUTINFO);
   DWORD current_idle_time = 0;
@@ -31,7 +37,10 @@ DWORD CalculateIdleTimeInternal() {
     current_idle_time /= 1000;
   }
 
-  return current_idle_time;
+  if (current_idle_time >= idle_threshold)
+    notify.Run(IDLE_STATE_IDLE);
+  else
+    notify.Run(IDLE_STATE_ACTIVE);
 }
 
 bool IsScreensaverRunning() {
@@ -59,12 +68,6 @@ bool IsWorkstationLocked() {
   return is_locked;
 }
 
-}  // namespace
-
-void CalculateIdleTime(IdleTimeCallback notify) {
-  notify.Run(static_cast<int>(CalculateIdleTimeInternal()));
-}
-
 bool CheckIdleStateIsLocked() {
   return IsWorkstationLocked() || IsScreensaverRunning();
 }
diff --git a/chrome/browser/notifications/notification_ui_manager_impl.cc b/chrome/browser/notifications/notification_ui_manager_impl.cc
index 21b4b01..587efda5 100644
--- a/chrome/browser/notifications/notification_ui_manager_impl.cc
+++ b/chrome/browser/notifications/notification_ui_manager_impl.cc
@@ -54,14 +54,12 @@ NotificationUIManagerImpl::NotificationUIManagerImpl(PrefService* local_state)
   position_pref_.Init(prefs::kDesktopNotificationPosition, local_state, this);
 #if defined(OS_MACOSX)
   InitFullScreenMonitor();
-  InitIdleMonitor();
 #endif
 }
 
 NotificationUIManagerImpl::~NotificationUIManagerImpl() {
   STLDeleteElements(&show_queue_);
 #if defined(OS_MACOSX)
-  StopIdleMonitor();
   StopFullScreenMonitor();
 #endif
 }
diff --git a/chrome/browser/policy/device_status_collector.cc b/chrome/browser/policy/device_status_collector.cc
index 82d5a61..4505c554 100644
--- a/chrome/browser/policy/device_status_collector.cc
+++ b/chrome/browser/policy/device_status_collector.cc
@@ -31,7 +31,7 @@ namespace em = enterprise_management;
 
 namespace {
 // How many seconds of inactivity triggers the idle state.
-const int kIdleStateThresholdSeconds = 300;
+const unsigned int kIdleStateThresholdSeconds = 300;
 
 // How many days in the past to store active periods for.
 const unsigned int kMaxStoredPastActivityDays = 30;
diff --git a/chrome/browser/profiles/profile_dependency_manager.cc b/chrome/browser/profiles/profile_dependency_manager.cc
index 40cc47a..6674498 100644
--- a/chrome/browser/profiles/profile_dependency_manager.cc
+++ b/chrome/browser/profiles/profile_dependency_manager.cc
@@ -17,7 +17,6 @@
 #include "chrome/browser/extensions/api/bluetooth/bluetooth_api_factory.h"
 #include "chrome/browser/extensions/api/commands/command_service_factory.h"
 #include "chrome/browser/extensions/api/discovery/suggested_links_registry_factory.h"
-#include "chrome/browser/extensions/api/idle/idle_manager_factory.h"
 #include "chrome/browser/extensions/api/processes/processes_api_factory.h"
 #include "chrome/browser/extensions/api/tab_capture/tab_capture_registry_factory.h"
 #include "chrome/browser/extensions/app_restore_service_factory.h"
@@ -225,7 +224,6 @@ void ProfileDependencyManager::AssertFactoriesBuilt() {
   extensions::AppRestoreServiceFactory::GetInstance();
   extensions::BluetoothAPIFactory::GetInstance();
   extensions::CommandServiceFactory::GetInstance();
-  extensions::IdleManagerFactory::GetInstance();
   extensions::SuggestedLinksRegistryFactory::GetInstance();
   extensions::ExtensionSystemFactory::GetInstance();
   extensions::ProcessesAPIFactory::GetInstance();
diff --git a/chrome/chrome_browser.gypi b/chrome/chrome_browser.gypi
index 21b91ac3..5545ab8 100644
--- a/chrome/chrome_browser.gypi
+++ b/chrome/chrome_browser.gypi
@@ -825,8 +825,6 @@
         'browser/icon_manager_linux.cc',
         'browser/icon_manager_mac.mm',
         'browser/icon_manager_win.cc',
-        'browser/idle.cc',
-        'browser/idle.h',
         'browser/idle_android.cc',
         'browser/idle_chromeos.cc',
         'browser/idle_linux.cc',
diff --git a/chrome/chrome_browser_extensions.gypi b/chrome/chrome_browser_extensions.gypi
index c4e4685..f48d260 100644
--- a/chrome/chrome_browser_extensions.gypi
+++ b/chrome/chrome_browser_extensions.gypi
@@ -184,10 +184,6 @@
         'browser/extensions/api/idle/idle_api.h',
         'browser/extensions/api/idle/idle_api_constants.cc',
         'browser/extensions/api/idle/idle_api_constants.h',
-        'browser/extensions/api/idle/idle_manager.cc',
-        'browser/extensions/api/idle/idle_manager.h',
-        'browser/extensions/api/idle/idle_manager_factory.cc',
-        'browser/extensions/api/idle/idle_manager_factory.h',
         'browser/extensions/api/idltest/idltest_api.cc',
         'browser/extensions/api/idltest/idltest_api.h',
         'browser/extensions/api/input/input.cc',
@@ -894,3 +890,4 @@
     }, ],  # 'OS=="win"'
   ],  # 'conditions'
 }
+
diff --git a/chrome/common/extensions/api/idle.json b/chrome/common/extensions/api/idle.json
index 3672056..03ad9af4 100644
--- a/chrome/common/extensions/api/idle.json
+++ b/chrome/common/extensions/api/idle.json
@@ -10,13 +10,13 @@
       {
         "name": "queryState",
         "type": "function",
-        "description": "Returns \"locked\" if the system is locked, \"idle\" if the user has not generated any input for a specified number of seconds, or \"active\" otherwise.",
+        "description": "Returns the current state of the browser.",
         "parameters": [
           {
-            "name": "detectionIntervalInSeconds",
+            "name": "thresholdSeconds",
             "type": "integer",
             "minimum": 15,
-            "description": "The system is considered idle if detectionIntervalInSeconds seconds have elapsed since the last user input detected."
+            "description": "Threshold, in seconds, used to determine when a machine is in the idle state."
           },
           {
             "name": "callback",
@@ -30,31 +30,18 @@
             ]
           }
         ]
-      },
-      {
-        "name": "setDetectionInterval",
-        "type": "function",
-        "description": "Sets the interval, in seconds, used to determine when the system is in an idle state for onStateChanged events. The default interval is 60 seconds.",
-        "parameters": [
-          {
-            "name": "intervalInSeconds",
-            "type": "integer",
-            "minimum": 15,
-            "description": "Threshold, in seconds, used to determine when the system is in an idle state."
-          }
-        ]
       }
     ],
     "events": [
       {
         "name": "onStateChanged",
         "type": "function",
-        "description": "Fired when the system changes to an active, idle or locked state. The event fires with \"locked\" if the screen is locked or the screensaver activates, \"idle\" if the system is unlocked and the user has not generated any input for a specified number of seconds, and \"active\" when the user generates input on an idle system.",
+        "description": "Fired when the browser changes to an active state.  Currently only reports the transition from idle to active.",
         "parameters": [
           {
             "name": "newState",
             "type": "string",
-            "enum": ["active", "idle", "locked"]
+            "enum": ["active"]
           }
         ]
       }