Refactor renderer-side script injection

chrome/browser/extensions/active_script_controller.cc

 // 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/extensions/active_script_controller.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
@@ skipping 201 matching lines @@
        ++request) {
     // Only run if it's on the proper page.
     if (request->page_id == page_id)
       request->closure.Run();
   }
 
   // Inform the location bar that the action is now gone.
   LocationBarController::NotifyChange(web_contents());
 }
 
-void ActiveScriptController::OnRequestContentScriptPermission(
+void ActiveScriptController::OnRequestScriptInjectionPermission(
     const std::string& extension_id,
     int page_id,
     int request_id) {
   if (!Extension::IdIsValid(extension_id)) {
     NOTREACHED() << "'" << extension_id << "' is not a valid id.";
     return;
   }
 
   const Extension* extension =
       ExtensionRegistry::Get(web_contents()->GetBrowserContext())
@@ skipping 11 matching lines @@
     permitted_extensions_.insert(extension->id());
     return;
   }
 
   if (RequiresUserConsentForScriptInjection(extension)) {
     // This base::Unretained() is safe, because the callback is only invoked by
     // this object.
     RequestScriptInjection(
         extension,
         page_id,
-        base::Bind(&ActiveScriptController::GrantContentScriptPermission,
+        base::Bind(&ActiveScriptController::PermitScriptInjection,
                    base::Unretained(this),
                    request_id));
   } else {
-    GrantContentScriptPermission(request_id);
+    PermitScriptInjection(request_id);
   }
 }
 
-void ActiveScriptController::GrantContentScriptPermission(int request_id) {
+void ActiveScriptController::PermitScriptInjection(int request_id) {
   content::RenderViewHost* render_view_host =
       web_contents()->GetRenderViewHost();
   if (render_view_host) {
-    render_view_host->Send(new ExtensionMsg_GrantContentScriptPermission(
-                               render_view_host->GetRoutingID(),
-                               request_id));
+    render_view_host->Send(new ExtensionMsg_PermitScriptInjection(
+        render_view_host->GetRoutingID(), request_id));
   }
 }
 
 bool ActiveScriptController::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(ActiveScriptController, message)
-    IPC_MESSAGE_HANDLER(ExtensionHostMsg_RequestContentScriptPermission,
-                        OnRequestContentScriptPermission)
+    IPC_MESSAGE_HANDLER(ExtensionHostMsg_RequestScriptInjectionPermission,
+                        OnRequestScriptInjectionPermission)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void ActiveScriptController::LogUMA() const {
   UMA_HISTOGRAM_COUNTS_100(
       "Extensions.ActiveScriptController.ShownActiveScriptsOnPage",
       pending_requests_.size());
 
   // We only log the permitted extensions metric if the feature is enabled,
   // because otherwise the data will be boring (100% allowed).
   if (enabled_) {
     UMA_HISTOGRAM_COUNTS_100(
         "Extensions.ActiveScriptController.PermittedExtensions",
         permitted_extensions_.size());
     UMA_HISTOGRAM_COUNTS_100(
         "Extensions.ActiveScriptController.DeniedExtensions",
         pending_requests_.size());
   }
 }
 
 }  // namespace extensions