Move c/r/extensions/* into extensions namespace

chrome/renderer/extensions/user_script_scheduler.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/renderer/extensions/user_script_scheduler.h"
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "chrome/common/extensions/extension_error_utils.h"
 #include "chrome/common/extensions/extension_manifest_constants.h"
 #include "chrome/common/extensions/extension_messages.h"
-#include "chrome/renderer/extensions/extension_dispatcher.h"
+#include "chrome/renderer/extensions/dispatcher.h"
 #include "chrome/renderer/extensions/extension_groups.h"
 #include "chrome/renderer/extensions/extension_helper.h"
 #include "chrome/renderer/extensions/user_script_slave.h"
 #include "content/public/renderer/render_view.h"
 #include "content/public/renderer/v8_value_converter.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebString.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebVector.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
 #include "v8/include/v8.h"
 
 namespace {
 // The length of time to wait after the DOM is complete to try and run user
 // scripts.
 const int kUserScriptIdleTimeoutMs = 200;
 }
 
 using WebKit::WebDocument;
 using WebKit::WebFrame;
 using WebKit::WebString;
 using WebKit::WebVector;
 using WebKit::WebView;
 
 namespace extensions {
 
-UserScriptScheduler::UserScriptScheduler(
-    WebFrame* frame, ExtensionDispatcher* extension_dispatcher)
+UserScriptScheduler::UserScriptScheduler(WebFrame* frame,
+                                         Dispatcher* dispatcher)
     : ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
       frame_(frame),
       current_location_(UserScript::UNDEFINED),
       has_run_idle_(false),
-      extension_dispatcher_(extension_dispatcher) {
+      dispatcher_(dispatcher) {
   for (int i = UserScript::UNDEFINED; i < UserScript::RUN_LOCATION_LAST; ++i) {
     pending_execution_map_[static_cast<UserScript::RunLocation>(i)] =
       std::queue<linked_ptr<ExtensionMsg_ExecuteCode_Params> >();
   }
 }
 
 UserScriptScheduler::~UserScriptScheduler() {
 }
 
 void UserScriptScheduler::ExecuteCode(
@@ skipping 52 matching lines @@
   current_location_ = UserScript::DOCUMENT_IDLE;
   MaybeRun();
 }
 
 void UserScriptScheduler::MaybeRun() {
   if (current_location_ == UserScript::UNDEFINED)
     return;
 
   if (!has_run_idle_ && current_location_ == UserScript::DOCUMENT_IDLE) {
     has_run_idle_ = true;
-    extension_dispatcher_->user_script_slave()->InjectScripts(
+    dispatcher_->user_script_slave()->InjectScripts(
         frame_, UserScript::DOCUMENT_IDLE);
   }
 
   // Run all tasks from the current time and earlier.
   for (int i = UserScript::DOCUMENT_START;
        i <= current_location_; ++i) {
     UserScript::RunLocation run_time = static_cast<UserScript::RunLocation>(i);
     while (!pending_execution_map_[run_time].empty()) {
       linked_ptr<ExtensionMsg_ExecuteCode_Params>& params =
         pending_execution_map_[run_time].front();
       ExecuteCodeImpl(*params);
       pending_execution_map_[run_time].pop();
     }
   }
 }
 
 void UserScriptScheduler::ExecuteCodeImpl(
     const ExtensionMsg_ExecuteCode_Params& params) {
-  const Extension* extension = extension_dispatcher_->extensions()->GetByID(
+  const Extension* extension = dispatcher_->extensions()->GetByID(
       params.extension_id);
   content::RenderView* render_view =
       content::RenderView::FromWebView(frame_->view());
   ExtensionHelper* extension_helper = ExtensionHelper::Get(render_view);
   base::ListValue execution_results;
 
   // Since extension info is sent separately from user script info, they can
   // be out of sync. We just ignore this situation.
   if (!extension) {
     render_view->Send(new ExtensionHostMsg_ExecuteCodeFinished(
@@ skipping 56 matching lines @@
           content::V8ValueConverter::create());
       v8_converter->SetUndefinedAllowed(true);
       v8::Handle<v8::Value> script_value;
       if (params.in_main_world) {
         script_value = frame->executeScriptAndReturnValue(source);
       } else {
         WebKit::WebVector<v8::Local<v8::Value> > results;
         std::vector<WebScriptSource> sources;
         sources.push_back(source);
         frame->executeScriptInIsolatedWorld(
-            extension_dispatcher_->user_script_slave()->
+            dispatcher_->user_script_slave()->
                 GetIsolatedWorldIdForExtension(extension, frame),
             &sources.front(), sources.size(), EXTENSION_GROUP_CONTENT_SCRIPTS,
             &results);
         // We only expect one value back since we only pushed one source
         if (results.size() == 1 && !results[0].IsEmpty())
           script_value = results[0];
       }
       if (!script_value.IsEmpty()) {
         base::Value* base_val =
             v8_converter->FromV8Value(script_value, context);
@@ skipping 25 matching lines @@
 
   for (WebFrame* child_frame = parent_frame->firstChild(); child_frame;
        child_frame = child_frame->nextSibling()) {
     frames_vector->push_back(child_frame);
     GetAllChildFrames(child_frame, frames_vector);
   }
   return true;
 }
 
 }  // namespace extensions