Moved c/b/e/*idle* to c/b/e/api/idle/

chrome/browser/extensions/api/idle/idle_api.cc

 // 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/extension_idle_api.h"
+#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/extension_event_router.h"
 #include "chrome/browser/extensions/extension_host.h"
-#include "chrome/browser/extensions/extension_idle_api_constants.h"
+#include "chrome/browser/extensions/api/idle/idle_api_constants.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/extensions/extension.h"
 #include "content/public/browser/render_view_host.h"
 
-namespace keys = extension_idle_api_constants;
+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
@@ skipping 35 matching lines @@
 
   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);
+    extensions::ExtensionIdleEventRouter::OnIdleStateChange(profile_,

[Yoyo Zhou, 2012/07/30 08:16:27]

If you're using this class you shouldn't need the extensions namespace on it.

[mitchellwrosen, 2012/07/30 17:29:20]

Done.

+                                                            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_);
 
@@ skipping 35 matching lines @@
   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
 
 void ExtensionIdleEventRouter::OnIdleStateChange(Profile* profile,
                                                  IdleState state) {
   // Prepare the single argument of the current state.
   ListValue args;
   args.Append(CreateIdleValue(state));
   std::string json_args;
   base::JSONWriter::Write(&args, &json_args);
 
   profile->GetExtensionEventRouter()->DispatchEventToRenderers(
@@ skipping 114 matching lines @@
   }
 }
 
 int ExtensionIdleCache::get_min_threshold() {
   return kMinThreshold;
 }
 
 double ExtensionIdleCache::get_throttle_interval() {
   return static_cast<double>(kThrottleInterval);
 }