Disable modifying extensions when in managed mode.

chrome/browser/managed_mode_unittest.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/managed_mode.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 19 matching lines @@
   void set_should_cancel_enter(bool should_cancel_enter) {
     should_cancel_enter_ = should_cancel_enter;
   }
 
   void EnterManagedModeForTesting(Profile* profile,
                                   const base::Callback<void(bool)>& callback) {
     EnterManagedModeImpl(profile, callback);
   }
 
   // ManagedMode overrides:
-  virtual bool IsInManagedModeImpl() OVERRIDE {
+  virtual bool IsInManagedModeImpl() const OVERRIDE {
     return in_managed_mode_;
   }
 
-  virtual void SetInManagedMode(bool in_managed_mode) OVERRIDE {
-    in_managed_mode_ = in_managed_mode;
+  virtual void SetInManagedMode(Profile* newly_managed_profile) OVERRIDE {
+    if (newly_managed_profile)
+      DCHECK(!managed_profile_ || managed_profile_ == newly_managed_profile);

[Bernhard Bauer, 2012/06/19 13:01:04]

Could you ASSERT instead of DCHECK so that we fail instead of crashing?

[Pam (message me for reviews), 2012/06/19 20:37:46]

Doh. Of course.

+    managed_profile_ = newly_managed_profile;
+    in_managed_mode_ = (newly_managed_profile != NULL);
   }
 
   virtual bool PlatformConfirmEnter() OVERRIDE {
     return !should_cancel_enter_;
   }
 
   virtual bool PlatformConfirmLeave() OVERRIDE {
     return true;
   }
 
@@ skipping 33 matching lines @@
   FakeManagedMode* managed_mode_;
 };
 
 class MockCallback : public base::RefCountedThreadSafe<MockCallback> {
  public:
   explicit MockCallback(FakeManagedMode* managed_mode)
       : managed_mode_(managed_mode) {
   }
 
   void CheckManagedMode(bool success) {
-    EXPECT_EQ(managed_mode_->IsInManagedModeImpl(), success);
+    EXPECT_EQ(success, managed_mode_->IsInManagedModeImpl());
     DidEnterManagedMode(success);
   }
 
   MOCK_METHOD1(DidEnterManagedMode, void(bool));
 
  protected:
   virtual ~MockCallback() {}
 
  private:
   friend class base::RefCountedThreadSafe<MockCallback>;
@@ skipping 34 matching lines @@
   // If there are no browsers belonging to a different profile, entering should
   // immediately succeed.
   managed_mode_.EnterManagedModeForTesting(&managed_mode_profile_,
                                            CreateExpectedCallback(true));
 }
 
 TEST_F(ManagedModeTest, AlreadyInManagedMode) {
   BrowserFixture managed_mode_browser(&managed_mode_, &managed_mode_profile_);
   BrowserFixture other_browser(&managed_mode_, &other_profile_);
 
-  // If we're already in managed mode, entering should immediately succeed.
-  managed_mode_.SetInManagedMode(true);
+  // If we're already in managed mode in this profile, entering should
+  // immediately succeed.
+  managed_mode_.SetInManagedMode(&managed_mode_profile_);
   managed_mode_.EnterManagedModeForTesting(&managed_mode_profile_,
                                            CreateExpectedCallback(true));
 }
 
 TEST_F(ManagedModeTest, QueueRequests) {
   BrowserFixture managed_mode_browser(&managed_mode_, &managed_mode_profile_);
 
   // Keep this before the other browser is constructed, so we verify its
   // expectations after the browser is destroyed.
   scoped_refptr<MockCallback> callback = CreateCallback();
@@ skipping 55 matching lines @@
 
 TEST_F(ManagedModeTest, Cancelled) {
   BrowserFixture managed_mode_browser(&managed_mode_, &managed_mode_profile_);
   BrowserFixture other_browser(&managed_mode_, &other_profile_);
 
   // If the user cancelled entering managed mode, it should fail immediately.
   managed_mode_.set_should_cancel_enter(true);
   managed_mode_.EnterManagedModeForTesting(&managed_mode_profile_,
                                            CreateExpectedCallback(false));
 }
+
+TEST_F(ManagedModeTest, ExtensionManagementPolicyProvider) {
+  BrowserFixture managed_mode_browser(&managed_mode_, &managed_mode_profile_);
+
+  EXPECT_TRUE(managed_mode_.UserMayLoad(NULL, NULL));
+  EXPECT_TRUE(managed_mode_.UserMayModifySettings(NULL, NULL));
+
+  managed_mode_.SetInManagedMode(&managed_mode_profile_);
+  EXPECT_FALSE(managed_mode_.UserMayLoad(NULL, NULL));
+  EXPECT_FALSE(managed_mode_.UserMayModifySettings(NULL, NULL));
+
+#ifndef NDEBUG
+  EXPECT_FALSE(managed_mode_.GetDebugPolicyProviderName().empty());
+#endif
+}