ifdef more extensions code to be used only when extensions are enabled.

chrome/browser/chrome_content_browser_client.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/chrome_content_browser_client.h"
 
 #include <set>
 #include <utility>
 #include <vector>
 
@@ skipping 1404 matching lines @@
     return true;
 
   // Otherwise, swap BrowsingInstances if current_extension and new_extension
   // differ.
   return current_extension != new_extension;
 }
 
 bool ChromeContentBrowserClient::ShouldSwapProcessesForRedirect(
     content::ResourceContext* resource_context, const GURL& current_url,
     const GURL& new_url) {
+#if defined(ENABLE_EXTENSIONS)
   ProfileIOData* io_data = ProfileIOData::FromResourceContext(resource_context);
   return extensions::CrossesExtensionProcessBoundary(
       io_data->GetExtensionInfoMap()->extensions(),
       current_url, new_url, false);
+#else
+  return false;
+#endif
 }
 
 bool ChromeContentBrowserClient::ShouldAssignSiteForURL(const GURL& url) {
   return !url.SchemeIs(chrome::kChromeNativeScheme);
 }
 
 std::string ChromeContentBrowserClient::GetCanonicalEncodingNameByAliasName(
     const std::string& alias_name) {
   return CharacterEncoding::GetCanonicalEncodingNameByAliasName(alias_name);
 }
@@ skipping 424 matching lines @@
 
     process_map.insert(std::pair<int, int>(i->first, i->second));
 
     if (WebViewRendererState::GetInstance()->IsGuest(i->first))
       has_web_view_guest = true;
   }
   if (!has_web_view_guest) {
     FileSystemAccessed(url, render_frames, callback, allow);
     return;
   }
-  DCHECK(process_map.size() == 1);
+  DCHECK_EQ(1U, process_map.size());
   it = process_map.begin();
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&ChromeContentBrowserClient::
                   RequestFileSystemPermissionOnUIThread,
                   it->first,
                   it->second,
                   url,
                   allow,
@@ skipping 56 matching lines @@
                    i->first, i->second, url, name, !allow));
   }
 
   return allow;
 }
 
 net::URLRequestContext*
 ChromeContentBrowserClient::OverrideRequestContextForURL(
     const GURL& url, content::ResourceContext* context) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+#if defined(ENABLE_EXTENSIONS)
   if (url.SchemeIs(extensions::kExtensionScheme)) {
     ProfileIOData* io_data = ProfileIOData::FromResourceContext(context);
     return io_data->extensions_request_context();
   }
+#endif
 
   return NULL;
 }
 
 QuotaPermissionContext*
 ChromeContentBrowserClient::CreateQuotaPermissionContext() {
   return new ChromeQuotaPermissionContext();
 }
 
 void ChromeContentBrowserClient::AllowCertificateError(
@@ skipping 285 matching lines @@
     bool user_gesture,
     bool opener_suppressed,
     content::ResourceContext* context,
     int render_process_id,
     int opener_id,
     bool* no_javascript_access) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   *no_javascript_access = false;
 
-  ProfileIOData* io_data = ProfileIOData::FromResourceContext(context);
-  InfoMap* map = io_data->GetExtensionInfoMap();
-
   // If the opener is trying to create a background window but doesn't have
   // the appropriate permission, fail the attempt.
   if (container_type == WINDOW_CONTAINER_TYPE_BACKGROUND) {
+#if defined(ENABLE_EXTENSIONS)
+    ProfileIOData* io_data = ProfileIOData::FromResourceContext(context);
+    InfoMap* map = io_data->GetExtensionInfoMap();
     if (!map->SecurityOriginHasAPIPermission(
             source_origin,
             render_process_id,
             APIPermission::kBackground)) {
       return false;
     }
 
     // Note: this use of GetExtensionOrAppByURL is safe but imperfect.  It may
     // return a recently installed Extension even if this CanCreateWindow call
     // was made by an old copy of the page in a normal web process.  That's ok,
     // because the permission check above would have caused an early return
     // already. We must use the full URL to find hosted apps, though, and not
     // just the origin.
     const Extension* extension =
         map->extensions().GetExtensionOrAppByURL(opener_url);
     if (extension && !extensions::BackgroundInfo::AllowJSAccess(extension))
       *no_javascript_access = true;
+#endif
 
     return true;
   }
 
 #if defined(ENABLE_EXTENSIONS)
   if (WebViewRendererState::GetInstance()->IsGuest(render_process_id))
     return true;
 #endif
 
   HostContentSettingsMap* content_settings =
       ProfileIOData::FromResourceContext(context)->GetHostContentSettingsMap();
   BlockedWindowParams blocked_params(target_url,
-                                    referrer,
-                                    disposition,
-                                    features,
-                                    user_gesture,
-                                    opener_suppressed,
-                                    render_process_id,
-                                    opener_id);
+                                     referrer,
+                                     disposition,
+                                     features,
+                                     user_gesture,
+                                     opener_suppressed,
+                                     render_process_id,
+                                     opener_id);
 
   if (!user_gesture && !CommandLine::ForCurrentProcess()->HasSwitch(
         switches::kDisablePopupBlocking)) {
     if (content_settings->GetContentSetting(opener_top_level_frame_url,
                                             opener_top_level_frame_url,
                                             CONTENT_SETTINGS_TYPE_POPUPS,
                                             std::string()) !=
         CONTENT_SETTING_ALLOW) {
       BrowserThread::PostTask(BrowserThread::UI,
                               FROM_HERE,
@@ skipping 12 matching lines @@
     return false;
   }
 #endif
 
   return true;
 }
 
 std::string ChromeContentBrowserClient::GetWorkerProcessTitle(
     const GURL& url, content::ResourceContext* context) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+#if defined(ENABLE_EXTENSIONS)
   // Check if it's an extension-created worker, in which case we want to use
   // the name of the extension.
   ProfileIOData* io_data = ProfileIOData::FromResourceContext(context);
   const Extension* extension =
       io_data->GetExtensionInfoMap()->extensions().GetByID(url.host());
   return extension ? extension->name() : std::string();
+#else
+  return std::string();
+#endif
 }
 
 void ChromeContentBrowserClient::ResourceDispatcherHostCreated() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   prerender_tracker_ = g_browser_process->prerender_tracker();
   return g_browser_process->ResourceDispatcherHostCreated();
 }
 
 // TODO(tommi): Rename from Get to Create.
 content::SpeechRecognitionManagerDelegate*
@@ skipping 547 matching lines @@
       switches::kDisableWebRtcEncryption,
     };
     to_command_line->CopySwitchesFrom(from_command_line,
                                       kWebRtcDevSwitchNames,
                                       arraysize(kWebRtcDevSwitchNames));
   }
 }
 #endif  // defined(ENABLE_WEBRTC)
 
 }  // namespace chrome