Add more management policy checking after extension installed

chrome/browser/extensions/extension_prefs_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/extensions/./extension_prefs_unittest.h"
 
 #include "base/basictypes.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/path_service.h"
 #include "base/prefs/mock_pref_change_callback.h"
@@ skipping 436 matching lines @@
     manifest.SetString(manifest_keys::kVersion, "1." + base::IntToString(num));
     base::FilePath path =
         prefs_.extensions_dir().AppendASCII(base::IntToString(num));
     std::string errors;
     scoped_refptr<Extension> extension = Extension::Create(
         path, Manifest::INTERNAL, manifest, Extension::NO_FLAGS, id, &errors);
     ASSERT_TRUE(extension.get()) << errors;
     ASSERT_EQ(id, extension->id());
     prefs()->SetDelayedInstallInfo(extension.get(),
                                    Extension::ENABLED,
+                                   Extension::DISABLE_NONE,
                                    kInstallFlagNone,
                                    ExtensionPrefs::DELAY_REASON_WAIT_FOR_IDLE,
                                    syncer::StringOrdinal(),
                                    std::string());
   }
 
   // Verifies that we get back expected idle install information previously
   // set by SetIdleInfo.
   void VerifyIdleInfo(const std::string& id, int num) {
     scoped_ptr<ExtensionInfo> info(prefs()->GetDelayedInstallInfo(id));
@@ skipping 105 matching lines @@
     manifest.Set(manifest_keys::kBackgroundScripts, scripts.release());
     base::FilePath path =
         prefs_.extensions_dir().AppendASCII("test_0.2");
     std::string errors;
     scoped_refptr<Extension> new_extension = Extension::Create(
         path, Manifest::INTERNAL, manifest, Extension::NO_FLAGS, id_, &errors);
     ASSERT_TRUE(new_extension.get()) << errors;
     ASSERT_EQ(id_, new_extension->id());
     prefs()->SetDelayedInstallInfo(new_extension.get(),
                                    Extension::ENABLED,
+                                   Extension::DISABLE_NONE,
                                    kInstallFlagNone,
                                    ExtensionPrefs::DELAY_REASON_WAIT_FOR_IDLE,
                                    syncer::StringOrdinal(),
                                    "Param");
 
     // Finish idle installation
     ASSERT_TRUE(prefs()->FinishDelayedInstallInfo(id_));
   }
 
   void Verify() override {
@@ skipping 19 matching lines @@
 };
 TEST_F(ExtensionPrefsFinishDelayedInstallInfo, FinishDelayedInstallInfo) {}
 
 class ExtensionPrefsOnExtensionInstalled : public ExtensionPrefsTest {
  public:
   void Initialize() override {
     extension_ = prefs_.AddExtension("on_extension_installed");
     EXPECT_FALSE(prefs()->IsExtensionDisabled(extension_->id()));
     prefs()->OnExtensionInstalled(extension_.get(),
                                   Extension::DISABLED,
+                                  Extension::DISABLE_NOT_VERIFIED,
                                   syncer::StringOrdinal(),
                                   "Param");
   }
 
   void Verify() override {
     EXPECT_TRUE(prefs()->IsExtensionDisabled(extension_->id()));
+    EXPECT_EQ(Extension::DISABLE_NOT_VERIFIED,
+              prefs()->GetDisableReasons(extension_->id()));
     EXPECT_EQ(std::string("Param"), prefs()->GetInstallParam(extension_->id()));
   }
 
  private:
   scoped_refptr<Extension> extension_;
 };
 TEST_F(ExtensionPrefsOnExtensionInstalled,
        ExtensionPrefsOnExtensionInstalled) {}
 
 class ExtensionPrefsAppDraggedByUser : public ExtensionPrefsTest {
  public:
   void Initialize() override {
     extension_ = prefs_.AddExtension("on_extension_installed");
     EXPECT_FALSE(prefs()->WasAppDraggedByUser(extension_->id()));
     prefs()->OnExtensionInstalled(extension_.get(),
                                   Extension::ENABLED,
+                                  Extension::DISABLE_NONE,
                                   syncer::StringOrdinal(),
                                   std::string());
   }
 
   void Verify() override {
     // Set the flag and see if it persisted.
     prefs()->SetAppDraggedByUser(extension_->id());
     EXPECT_TRUE(prefs()->WasAppDraggedByUser(extension_->id()));
 
     // Make sure it doesn't change on consecutive calls.
@@ skipping 218 matching lines @@
     EXPECT_FALSE(prefs()->IsExtensionBlacklisted(extension_a_->id()));
     EXPECT_EQ(empty_ids, prefs()->GetBlacklistedExtensions());
   }
 
  private:
   scoped_refptr<const Extension> extension_a_;
 };
 TEST_F(ExtensionPrefsBlacklistState, ExtensionPrefsBlacklistState) {}
 
 }  // namespace extensions