Cleanup: Remove most enable_extensions logic in extensions code.

extensions/renderer/dispatcher.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 "extensions/renderer/dispatcher.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/debug/alias.h"
@@ skipping 171 matching lines @@
 Dispatcher::Dispatcher(DispatcherDelegate* delegate)
     : delegate_(delegate),
       content_watcher_(new ContentWatcher()),
       source_map_(&ResourceBundle::GetSharedInstance()),
       v8_schema_registry_(new V8SchemaRegistry),
       is_webkit_initialized_(false),
       user_script_set_manager_observer_(this),
       webrequest_used_(false) {
   const CommandLine& command_line = *(CommandLine::ForCurrentProcess());
   is_extension_process_ =
-      command_line.HasSwitch(extensions::switches::kExtensionProcess) ||
+      command_line.HasSwitch(switches::kExtensionProcess) ||
       command_line.HasSwitch(::switches::kSingleProcess);
 
   if (is_extension_process_) {
     RenderThread::Get()->SetIdleNotificationDelayInMs(
         kInitialExtensionIdleHandlerDelayMs);
   }
 
   RenderThread::Get()->RegisterExtension(SafeBuiltins::CreateV8Extension());
 
   user_script_set_manager_.reset(new UserScriptSetManager(&extensions_));
@@ skipping 50 matching lines @@
     }
   }
   return extension;
 }
 
 void Dispatcher::DidCreateScriptContext(
     WebFrame* frame,
     const v8::Handle<v8::Context>& v8_context,
     int extension_group,
     int world_id) {
-#if !defined(ENABLE_EXTENSIONS)
-  return;
-#endif
-
   const Extension* extension =
       GetExtensionFromFrameAndWorld(frame, world_id, false);
   const Extension* effective_extension =
       GetExtensionFromFrameAndWorld(frame, world_id, true);
 
   GURL frame_url = ScriptContext::GetDataSourceURLForFrame(frame);
   Feature::Context context_type =
       ClassifyJavaScriptContext(extension,
                                 extension_group,
                                 frame_url,
@@ skipping 42 matching lines @@
   UpdateBindingsForContext(context);
 
   bool is_within_platform_app = IsWithinPlatformApp();
   // Inject custom JS into the platform app context.
   if (is_within_platform_app) {
     module_system->Require("platformApp");
   }
 
   if (context->GetAvailability("appViewEmbedderInternal").is_available()) {
     module_system->Require("appView");
-  } else if (context_type == extensions::Feature::BLESSED_EXTENSION_CONTEXT) {
+  } else if (context_type == Feature::BLESSED_EXTENSION_CONTEXT) {
     module_system->Require("denyAppView");
   }
 
   // Note: setting up the WebView class here, not the chrome.webview API.
   // The API will be automatically set up when first used.
   if (context->GetAvailability("webViewInternal").is_available()) {
     module_system->Require("webView");
     module_system->Require("webViewConstants");
     module_system->Require("webViewAttributes");
     if (context->GetAvailability("webViewExperimentalInternal")
             .is_available()) {
       module_system->Require("webViewExperimental");
     }
-  } else if (context_type == extensions::Feature::BLESSED_EXTENSION_CONTEXT) {
+  } else if (context_type == Feature::BLESSED_EXTENSION_CONTEXT) {
     module_system->Require("denyWebView");
   }
 
   delegate_->RequireAdditionalModules(context, is_within_platform_app);
 
   VLOG(1) << "Num tracked contexts: " << script_context_set_.size();
 }
 
 void Dispatcher::WillReleaseScriptContext(
     WebFrame* frame,
@@ skipping 32 matching lines @@
         &stylesheet, 0, "$FONTFAMILY", system_font_family_);
     ReplaceFirstSubstringAfterOffset(
         &stylesheet, 0, "$FONTSIZE", system_font_size_);
 
     // Blink doesn't let us define an additional user agent stylesheet, so
     // we insert the default platform app or extension stylesheet into all
     // documents that are loaded in each app or extension.
     frame->document().insertStyleSheet(WebString::fromUTF8(stylesheet));
   }
 
-  // This preprocessor directive is because this file is still built in Android
-  // builds, but OptionsPageInfo is not. For Android builds, exclude this block
-  // of code to prevent link errors.
-#if defined(ENABLE_EXTENSIONS)
   // If this is an extension options page, and the extension has opted into
   // using Chrome styles, then insert the Chrome extension stylesheet.
   if (extension && extension->is_extension() &&
       OptionsPageInfo::ShouldUseChromeStyle(extension) &&
       effective_document_url == OptionsPageInfo::GetOptionsPage(extension)) {
     frame->document().insertStyleSheet(
         WebString::fromUTF8(ResourceBundle::GetSharedInstance()
                                 .GetRawDataResource(IDR_EXTENSION_CSS)
                                 .as_string()));
   }
-#endif
 
   content_watcher_->DidCreateDocumentElement(frame);
 }
 
 void Dispatcher::DidMatchCSS(
     blink::WebFrame* frame,
     const blink::WebVector<blink::WebString>& newly_matching_selectors,
     const blink::WebVector<blink::WebString>& stopped_matching_selectors) {
   content_watcher_->DidMatchCSS(
       frame, newly_matching_selectors, stopped_matching_selectors);
@@ skipping 402 matching lines @@
     CHECK(extension) << extension_id << " was never loaded: " << error;
   }
 
   active_extension_ids_.insert(extension_id);
 
   // This is called when starting a new extension page, so start the idle
   // handler ticking.
   RenderThread::Get()->ScheduleIdleHandler(kInitialExtensionIdleHandlerDelayMs);
 
   if (is_webkit_initialized_) {
-    extensions::DOMActivityLogger::AttachToWorld(
-        extensions::DOMActivityLogger::kMainWorldId, extension_id);
+    DOMActivityLogger::AttachToWorld(
+        DOMActivityLogger::kMainWorldId, extension_id);
 
     InitOriginPermissions(extension);
   }
 
   UpdateActiveExtensions();
 }
 
 void Dispatcher::OnCancelSuspend(const std::string& extension_id) {
   DispatchEvent(extension_id, kOnSuspendCanceledEvent);
 }
@@ skipping 567 matching lines @@
     return v8::Handle<v8::Object>();
 
   if (bind_name)
     *bind_name = split.back();
 
   return bind_object.IsEmpty() ? AsObjectOrEmpty(GetOrCreateChrome(context))
                                : bind_object;
 }
 
 }  // namespace extensions