Add #ifdefs for the extensions parts of SupervisedUserService.

chrome/browser/supervised_user/supervised_user_service.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/supervised_user/supervised_user_service.h"
 
 #include "base/command_line.h"
 #include "base/memory/ref_counted.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
-#include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_info_cache.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/browser/supervised_user/custodian_profile_downloader_service.h"
 #include "chrome/browser/supervised_user/custodian_profile_downloader_service_factory.h"
 #include "chrome/browser/supervised_user/permission_request_creator_apiary.h"
 #include "chrome/browser/supervised_user/permission_request_creator_sync.h"
 #include "chrome/browser/supervised_user/supervised_user_constants.h"
 #include "chrome/browser/supervised_user/supervised_user_pref_mapping_service.h"
 #include "chrome/browser/supervised_user/supervised_user_pref_mapping_service_factory.h"
 #include "chrome/browser/supervised_user/supervised_user_registration_utility.h"
 #include "chrome/browser/supervised_user/supervised_user_settings_service.h"
 #include "chrome/browser/supervised_user/supervised_user_settings_service_factory.h"
 #include "chrome/browser/supervised_user/supervised_user_shared_settings_service_factory.h"
 #include "chrome/browser/supervised_user/supervised_user_site_list.h"
 #include "chrome/browser/supervised_user/supervised_user_sync_service.h"
 #include "chrome/browser/supervised_user/supervised_user_sync_service_factory.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/common/chrome_switches.h"
-#include "chrome/common/extensions/api/supervised_user_private/supervised_user_handler.h"
 #include "chrome/common/pref_names.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/signin/core/browser/profile_oauth2_token_service.h"
 #include "components/signin/core/browser/signin_manager.h"
 #include "components/signin/core/browser/signin_manager_base.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/user_metrics.h"
-#include "extensions/browser/extension_registry.h"
-#include "extensions/browser/extension_system.h"
-#include "extensions/common/extension_set.h"
 #include "google_apis/gaia/google_service_auth_error.h"
 #include "grit/generated_resources.h"
 #include "net/base/escape.h"
 #include "ui/base/l10n/l10n_util.h"
 
 #if defined(OS_CHROMEOS)

[Bernhard Bauer, 2014/07/11 10:50:02]

Could you move this down below ENABLE_THEMES?

[Lei Zhang, 2014/07/11 19:33:06]

Many files generally do OS_ #ifdefs ahead of feature #ifdefs, so I would prefer
to be consistent.

 #include "chrome/browser/chromeos/login/users/supervised_user_manager.h"
 #include "chrome/browser/chromeos/login/users/user_manager.h"
 #endif
 
+#if defined(ENABLE_EXTENSIONS)
+#include "chrome/browser/extensions/extension_service.h"
+#include "chrome/common/extensions/api/supervised_user_private/supervised_user_handler.h"
+#include "extensions/browser/extension_registry.h"
+#include "extensions/browser/extension_system.h"
+#include "extensions/common/extension_set.h"
+#endif
+
 #if defined(ENABLE_THEMES)
 #include "chrome/browser/themes/theme_service.h"
 #include "chrome/browser/themes/theme_service_factory.h"
 #endif
 
 using base::DictionaryValue;
 using base::UserMetricsAction;
 using content::BrowserThread;
 
 SupervisedUserService::URLFilterContext::URLFilterContext()
@@ skipping 56 matching lines @@
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(&SupervisedUserURLFilter::SetManualURLs,
                  io_url_filter_, base::Owned(url_map.release())));
 }
 
 SupervisedUserService::SupervisedUserService(Profile* profile)
     : profile_(profile),
       active_(false),
       delegate_(NULL),
+#if defined(ENABLE_EXTENSIONS)
       extension_registry_observer_(this),
+#endif
       waiting_for_sync_initialization_(false),
       is_profile_active_(false),
       elevated_for_testing_(false),
       did_shutdown_(false),
       waiting_for_permissions_(false),
       weak_ptr_factory_(this) {
 }
 
 SupervisedUserService::~SupervisedUserService() {
   DCHECK(did_shutdown_);
@@ skipping 100 matching lines @@
 
 void SupervisedUserService::DidBlockNavigation(
     content::WebContents* web_contents) {
   for (std::vector<NavigationBlockedCallback>::iterator it =
            navigation_blocked_callbacks_.begin();
        it != navigation_blocked_callbacks_.end(); ++it) {
     it->Run(web_contents);
   }
 }
 
+#if defined(ENABLE_EXTENSIONS)
 std::string SupervisedUserService::GetDebugPolicyProviderName() const {
   // Save the string space in official builds.
 #ifdef NDEBUG
   NOTREACHED();
   return std::string();
 #else
   return "Supervised User Service";
 #endif
 }
 
@@ skipping 33 matching lines @@
     *error = tmp_error;
   return false;
 }
 
 bool SupervisedUserService::UserMayModifySettings(
     const extensions::Extension* extension,
     base::string16* error) const {
   return ExtensionManagementPolicyImpl(extension, error);
 }
 
-void SupervisedUserService::OnStateChanged() {
-  ProfileSyncService* service =
-      ProfileSyncServiceFactory::GetForProfile(profile_);
-  if (waiting_for_sync_initialization_ && service->sync_initialized()) {
-    waiting_for_sync_initialization_ = false;
-    service->RemoveObserver(this);
-    FinishSetupSync();
-    return;
-  }
-
-  DLOG_IF(ERROR, service->GetAuthError().state() ==
-                     GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS)
-      << "Credentials rejected";
-}
-
 void SupervisedUserService::OnExtensionLoaded(
     content::BrowserContext* browser_context,
     const extensions::Extension* extension) {
   if (!extensions::SupervisedUserInfo::GetContentPackSiteList(extension)
            .empty()) {
     UpdateSiteLists();
   }
 }
 void SupervisedUserService::OnExtensionUnloaded(
     content::BrowserContext* browser_context,
     const extensions::Extension* extension,
     extensions::UnloadedExtensionInfo::Reason reason) {
   if (!extensions::SupervisedUserInfo::GetContentPackSiteList(extension)
            .empty()) {
     UpdateSiteLists();
   }
 }
+#endif  // defined(ENABLE_EXTENSIONS)
+
+void SupervisedUserService::OnStateChanged() {
+  ProfileSyncService* service =
+      ProfileSyncServiceFactory::GetForProfile(profile_);
+  if (waiting_for_sync_initialization_ && service->sync_initialized()) {
+    waiting_for_sync_initialization_ = false;
+    service->RemoveObserver(this);
+    FinishSetupSync();
+    return;
+  }
+
+  DLOG_IF(ERROR, service->GetAuthError().state() ==
+                     GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS)
+      << "Credentials rejected";
+}
 
 void SupervisedUserService::SetupSync() {
   StartSetupSync();
   FinishSetupSyncWhenReady();
 }
 
 void SupervisedUserService::StartSetupSync() {
   // Tell the sync service that setup is in progress so we don't start syncing
   // until we've finished configuration.
   ProfileSyncServiceFactory::GetForProfile(profile_)->SetSetupInProgress(true);
@@ skipping 23 matching lines @@
   bool sync_everything = false;
   syncer::ModelTypeSet synced_datatypes;
   synced_datatypes.Put(syncer::SESSIONS);
   service->OnUserChoseDatatypes(sync_everything, synced_datatypes);
 
   // Notify ProfileSyncService that we are done with configuration.
   service->SetSetupInProgress(false);
   service->SetSyncSetupCompleted();
 }
 
+#if defined(ENABLE_EXTENSIONS)
 bool SupervisedUserService::ExtensionManagementPolicyImpl(
     const extensions::Extension* extension,
     base::string16* error) const {
   // |extension| can be NULL in unit_tests.
   if (!ProfileIsSupervised() || (extension && extension->is_theme()))
     return true;
 
   if (elevated_for_testing_)
     return true;
 
@@ skipping 22 matching lines @@
         extensions::SupervisedUserInfo::GetContentPackSiteList(extension);
     if (!site_list.empty()) {
       site_lists.push_back(new SupervisedUserSiteList(extension->id(),
                                                       site_list.GetFilePath()));
     }
   }
 
   return site_lists.Pass();
 }
 
+void SupervisedUserService::SetExtensionsActive() {
+  extensions::ExtensionSystem* extension_system =
+      extensions::ExtensionSystem::Get(profile_);
+  extensions::ManagementPolicy* management_policy =
+      extension_system->management_policy();
+
+  if (active_) {
+    if (management_policy)
+      management_policy->RegisterProvider(this);
+
+    extension_registry_observer_.Add(
+        extensions::ExtensionRegistry::Get(profile_));
+  } else {
+    if (management_policy)
+      management_policy->UnregisterProvider(this);
+
+    extension_registry_observer_.RemoveAll();
+  }
+}
+#endif  // defined(ENABLE_EXTENSIONS)
+
 SupervisedUserSettingsService* SupervisedUserService::GetSettingsService() {
   return SupervisedUserSettingsServiceFactory::GetForProfile(profile_);
 }
 
 void SupervisedUserService::OnSupervisedUserIdChanged() {
   std::string supervised_user_id =
       profile_->GetPrefs()->GetString(prefs::kSupervisedUserId);
   SetActive(!supervised_user_id.empty());
 }
 
 void SupervisedUserService::OnDefaultFilteringBehaviorChanged() {
   DCHECK(ProfileIsSupervised());
 
   int behavior_value = profile_->GetPrefs()->GetInteger(
       prefs::kDefaultSupervisedUserFilteringBehavior);
   SupervisedUserURLFilter::FilteringBehavior behavior =
       SupervisedUserURLFilter::BehaviorFromInt(behavior_value);
   url_filter_context_.SetDefaultFilteringBehavior(behavior);
 }
 
 void SupervisedUserService::UpdateSiteLists() {
+#if defined(ENABLE_EXTENSIONS)
   url_filter_context_.LoadWhitelists(GetActiveSiteLists());
+#endif
 }
 
 bool SupervisedUserService::AccessRequestsEnabled() {
   if (waiting_for_permissions_)
     return false;
 
   ProfileSyncService* service =
       ProfileSyncServiceFactory::GetForProfile(profile_);
   GoogleServiceAuthError::State state = service->GetAuthError().state();
   // We allow requesting access if Sync is working or has a transient error.
@@ skipping 115 matching lines @@
   // Re-set the default theme to turn the SU theme on/off.
   ThemeService* theme_service = ThemeServiceFactory::GetForProfile(profile_);
   if (theme_service->UsingDefaultTheme() || theme_service->UsingSystemTheme()) {
     ThemeServiceFactory::GetForProfile(profile_)->UseDefaultTheme();
   }
 #endif
 
   SupervisedUserSettingsService* settings_service = GetSettingsService();
   settings_service->SetActive(active_);
 
-  extensions::ExtensionSystem* extension_system =
-      extensions::ExtensionSystem::Get(profile_);
-  extensions::ManagementPolicy* management_policy =
-      extension_system->management_policy();
+#if defined(ENABLE_EXTENSIONS)
+  SetExtensionsActive();
+#endif
 
   if (active_) {
     if (CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kPermissionRequestApiUrl)) {
       permissions_creator_ =
           PermissionRequestCreatorApiary::CreateWithProfile(profile_);
     } else {
       PrefService* pref_service = profile_->GetPrefs();
       permissions_creator_.reset(new PermissionRequestCreatorSync(
           settings_service,
           SupervisedUserSharedSettingsServiceFactory::GetForBrowserContext(
               profile_),
           pref_service->GetString(prefs::kProfileName),
           pref_service->GetString(prefs::kSupervisedUserId)));
     }
 
-    if (management_policy)
-      management_policy->RegisterProvider(this);
-
-    extension_registry_observer_.Add(
-        extensions::ExtensionRegistry::Get(profile_));
-
     pref_change_registrar_.Add(
         prefs::kDefaultSupervisedUserFilteringBehavior,
         base::Bind(&SupervisedUserService::OnDefaultFilteringBehaviorChanged,
             base::Unretained(this)));
     pref_change_registrar_.Add(prefs::kSupervisedUserManualHosts,
         base::Bind(&SupervisedUserService::UpdateManualHosts,
                    base::Unretained(this)));
     pref_change_registrar_.Add(prefs::kSupervisedUserManualURLs,
         base::Bind(&SupervisedUserService::UpdateManualURLs,
                    base::Unretained(this)));
 
     // Initialize the filter.
     OnDefaultFilteringBehaviorChanged();
     UpdateSiteLists();
     UpdateManualHosts();
     UpdateManualURLs();
 
 #if !defined(OS_ANDROID)
     // TODO(bauerb): Get rid of the platform-specific #ifdef here.
     // http://crbug.com/313377
     BrowserList::AddObserver(this);
 #endif
   } else {
     permissions_creator_.reset();
 
-    if (management_policy)
-      management_policy->UnregisterProvider(this);
-
-    extension_registry_observer_.RemoveAll();
-
     pref_change_registrar_.Remove(
         prefs::kDefaultSupervisedUserFilteringBehavior);
     pref_change_registrar_.Remove(prefs::kSupervisedUserManualHosts);
     pref_change_registrar_.Remove(prefs::kSupervisedUserManualURLs);
 
     if (waiting_for_sync_initialization_) {
       ProfileSyncService* sync_service =
           ProfileSyncServiceFactory::GetForProfile(profile_);
       sync_service->RemoveObserver(this);
     }
@@ skipping 95 matching lines @@
 
 void SupervisedUserService::OnBrowserSetLastActive(Browser* browser) {
   bool profile_became_active = profile_->IsSameProfile(browser->profile());
   if (!is_profile_active_ && profile_became_active)
     content::RecordAction(UserMetricsAction("ManagedUsers_OpenProfile"));
   else if (is_profile_active_ && !profile_became_active)
     content::RecordAction(UserMetricsAction("ManagedUsers_SwitchProfile"));
 
   is_profile_active_ = profile_became_active;
 }