Add a function triggering extension installed to ExtensionRegistryObserver

extensions/browser/extension_registry_unittest.cc

 // Copyright 2013 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/browser/extension_registry.h"
 
 #include <string>
 
 #include "base/memory/ref_counted.h"
+#include "base/strings/string_util.h"
 #include "extensions/browser/extension_registry_observer.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace extensions {
 namespace {
 
 typedef testing::Test ExtensionRegistryTest;
 
@@ skipping 10 matching lines @@
     return testing::AssertionFailure() << "Expected " << extension->id()
                                        << " found " << did_load->id();
   return testing::AssertionSuccess();
 }
 
 class TestObserver : public ExtensionRegistryObserver {
  public:
   void Reset() {
     loaded_.clear();
     unloaded_.clear();
+    installed_.clear();
   }
 
   const ExtensionList& loaded() { return loaded_; }
   const ExtensionList& unloaded() { return unloaded_; }
+  const ExtensionList& installed() { return installed_; }
 
  private:
   virtual void OnExtensionLoaded(content::BrowserContext* browser_context,
                                  const Extension* extension) OVERRIDE {
     loaded_.push_back(extension);
   }
 
   virtual void OnExtensionUnloaded(content::BrowserContext* browser_context,
                                    const Extension* extension,
                                    UnloadedExtensionInfo::Reason reason)
       OVERRIDE {
     unloaded_.push_back(extension);
   }
 
+  virtual void OnExtensionWillBeInstalled(
+      content::BrowserContext* browser_context,
+      const Extension* extension,
+      bool is_update,
+      const std::string& old_name) OVERRIDE {
+    installed_.push_back(extension);
+  }
+
   ExtensionList loaded_;
   ExtensionList unloaded_;
+  ExtensionList installed_;
 };
 
 TEST_F(ExtensionRegistryTest, FillAndClearRegistry) {
   ExtensionRegistry registry(NULL);
   scoped_refptr<Extension> extension1 = test_util::CreateExtensionWithID("id1");
   scoped_refptr<Extension> extension2 = test_util::CreateExtensionWithID("id2");
   scoped_refptr<Extension> extension3 = test_util::CreateExtensionWithID("id3");
   scoped_refptr<Extension> extension4 = test_util::CreateExtensionWithID("id4");
 
   // All the sets start empty.
@@ skipping 138 matching lines @@
       "enabled", ExtensionRegistry::DISABLED | ExtensionRegistry::BLACKLISTED));
 }
 
 TEST_F(ExtensionRegistryTest, Observer) {
   ExtensionRegistry registry(NULL);
   TestObserver observer;
   registry.AddObserver(&observer);
 
   EXPECT_TRUE(observer.loaded().empty());
   EXPECT_TRUE(observer.unloaded().empty());
+  EXPECT_TRUE(observer.installed().empty());
 
   scoped_refptr<const Extension> extension =
       test_util::CreateExtensionWithID("id");
 
+  registry.TriggerOnWillBeInstalled(extension, false, base::EmptyString());
+  EXPECT_TRUE(HasSingleExtension(observer.installed(), extension.get()));
+
   registry.AddEnabled(extension);
   registry.TriggerOnLoaded(extension);
 
+  registry.TriggerOnWillBeInstalled(extension, true, "foo");
+
   EXPECT_TRUE(HasSingleExtension(observer.loaded(), extension.get()));
   EXPECT_TRUE(observer.unloaded().empty());
   observer.Reset();
 
   registry.RemoveEnabled(extension->id());
   registry.TriggerOnUnloaded(extension, UnloadedExtensionInfo::REASON_DISABLE);
 
   EXPECT_TRUE(observer.loaded().empty());
   EXPECT_TRUE(HasSingleExtension(observer.unloaded(), extension.get()));
   observer.Reset();
 
   registry.RemoveObserver(&observer);
 }
 
 }  // namespace
 }  // namespace extensions