Implement an observer for the component updater.

chrome/browser/component_updater/test/component_updater_service_unittest.cc

 // Copyright 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/component_updater/test/component_updater_service_unittest.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
@@ skipping 17 matching lines @@
 using ::testing::_;
 using ::testing::InSequence;
 using ::testing::Mock;
 
 namespace component_updater {
 
 #define POST_INTERCEPT_SCHEME    "https"
 #define POST_INTERCEPT_HOSTNAME  "localhost2"
 #define POST_INTERCEPT_PATH      "/update2"
 
-MockComponentObserver::MockComponentObserver() {
+MockServiceObserver::MockServiceObserver() {
 }
 
-MockComponentObserver::~MockComponentObserver() {
+MockServiceObserver::~MockServiceObserver() {
 }
 
 bool PartialMatch::Match(const std::string& actual) const {
   return actual.find(expected_) != std::string::npos;
 }
 
 TestConfigurator::TestConfigurator()
     : initial_time_(0),
       times_(1),
       recheck_time_(0),
@@ skipping 195 matching lines @@
 TEST_F(ComponentUpdaterTest, StartStop) {
   component_updater()->Start();
   RunThreadsUntilIdle();
   component_updater()->Stop();
 }
 
 // Verify that when the server has no updates, we go back to sleep and
 // the COMPONENT_UPDATER_STARTED and COMPONENT_UPDATER_SLEEPING notifications
 // are generated. No pings are sent.
 TEST_F(ComponentUpdaterTest, CheckCrxSleep) {
-  MockComponentObserver observer;
+  MockServiceObserver observer;
 
   EXPECT_CALL(observer,
-              OnEvent(ComponentObserver::COMPONENT_UPDATER_STARTED, 0))
+              OnEvent(ServiceObserver::COMPONENT_UPDATER_STARTED, ""))
               .Times(1);
   EXPECT_CALL(observer,
-              OnEvent(ComponentObserver::COMPONENT_UPDATER_SLEEPING, 0))
+              OnEvent(ServiceObserver::COMPONENT_UPDATER_SLEEPING, ""))
               .Times(2);
   EXPECT_CALL(observer,
-              OnEvent(ComponentObserver::COMPONENT_NOT_UPDATED, 0))
+              OnEvent(ServiceObserver::COMPONENT_NOT_UPDATED,
+                      "abagagagagagagagagagagagagagagag"))
               .Times(2);
 
   EXPECT_TRUE(post_interceptor_->ExpectRequest(new PartialMatch(
       "updatecheck"), test_file("updatecheck_reply_1.xml")));
   EXPECT_TRUE(post_interceptor_->ExpectRequest(new PartialMatch(
       "updatecheck"), test_file("updatecheck_reply_1.xml")));
 
   TestInstaller installer;
   CrxComponent com;
-  com.observer = &observer;
+  component_updater()->AddObserver(&observer);
   EXPECT_EQ(ComponentUpdateService::kOk,
             RegisterComponent(&com,
                               kTestComponent_abag,
                               Version("1.1"),
                               &installer));
 
   // We loop twice, but there are no updates so we expect two sleep messages.
   test_configurator()->SetLoopCount(2);
   component_updater()->Start();
   RunThreads();
@@ skipping 14 matching lines @@
   EXPECT_NE(string::npos, post_interceptor_->GetRequests()[1].find(
       "<app appid=\"abagagagagagagagagagagagagagagag\" version=\"1.1\">"
       "<updatecheck /></app>"))
       << post_interceptor_->GetRequestsAsString();
 
   component_updater()->Stop();
 
   // Loop twice again but this case we simulate a server error by returning
   // an empty file. Expect the behavior of the service to be the same as before.
   EXPECT_CALL(observer,
-              OnEvent(ComponentObserver::COMPONENT_UPDATER_STARTED, 0))
+              OnEvent(ServiceObserver::COMPONENT_UPDATER_STARTED, ""))
               .Times(1);
   EXPECT_CALL(observer,
-              OnEvent(ComponentObserver::COMPONENT_UPDATER_SLEEPING, 0))
+              OnEvent(ServiceObserver::COMPONENT_UPDATER_SLEEPING, ""))
               .Times(2);
   EXPECT_CALL(observer,
-              OnEvent(ComponentObserver::COMPONENT_NOT_UPDATED, 0))
+              OnEvent(ServiceObserver::COMPONENT_NOT_UPDATED,
+                      "abagagagagagagagagagagagagagagag"))
               .Times(2);
 
   post_interceptor_->Reset();
   EXPECT_TRUE(post_interceptor_->ExpectRequest(new PartialMatch(
       "updatecheck"), test_file("updatecheck_reply_empty")));
   EXPECT_TRUE(post_interceptor_->ExpectRequest(new PartialMatch(
       "updatecheck"), test_file("updatecheck_reply_empty")));
 
   test_configurator()->SetLoopCount(2);
   component_updater()->Start();
@@ skipping 21 matching lines @@
 // Verify that we can check for updates and install one component. Besides
 // the notifications above COMPONENT_UPDATE_FOUND and COMPONENT_UPDATE_READY
 // should have been fired. We do two loops so the second time around there
 // should be nothing left to do.
 // We also check that the following network requests are issued:
 // 1- update check
 // 2- download crx
 // 3- ping
 // 4- second update check.
 TEST_F(ComponentUpdaterTest, InstallCrx) {
-  MockComponentObserver observer1;
+  MockServiceObserver observer;
   {
     InSequence seq;
-    EXPECT_CALL(observer1,
-                OnEvent(ComponentObserver::COMPONENT_UPDATER_STARTED, 0))
+    EXPECT_CALL(observer,
+                OnEvent(ServiceObserver::COMPONENT_UPDATER_STARTED, ""))
                 .Times(1);
-    EXPECT_CALL(observer1,
-                OnEvent(ComponentObserver::COMPONENT_UPDATE_FOUND, 0))
+    EXPECT_CALL(observer,
+                OnEvent(ServiceObserver::COMPONENT_UPDATE_FOUND,
+                        "jebgalgnebhfojomionfpkfelancnnkf"))
                 .Times(1);
-    EXPECT_CALL(observer1,
-                OnEvent(ComponentObserver::COMPONENT_UPDATE_READY, 0))
+    EXPECT_CALL(observer,
+                OnEvent(ServiceObserver::COMPONENT_NOT_UPDATED,
+                        "abagagagagagagagagagagagagagagag"))
                 .Times(1);
-    EXPECT_CALL(observer1,
-                OnEvent(ComponentObserver::COMPONENT_UPDATED, 0))
+    EXPECT_CALL(observer,
+                OnEvent(ServiceObserver::COMPONENT_UPDATE_READY,
+                        "jebgalgnebhfojomionfpkfelancnnkf"))
                 .Times(1);
-    EXPECT_CALL(observer1,
-                OnEvent(ComponentObserver::COMPONENT_UPDATER_SLEEPING, 0))
+    EXPECT_CALL(observer,
+                OnEvent(ServiceObserver::COMPONENT_UPDATED,
+                        "jebgalgnebhfojomionfpkfelancnnkf"))
                 .Times(1);
-    EXPECT_CALL(observer1,
-                OnEvent(ComponentObserver::COMPONENT_NOT_UPDATED, 0))
+    EXPECT_CALL(observer,
+                OnEvent(ServiceObserver::COMPONENT_UPDATER_SLEEPING, ""))
                 .Times(1);
-    EXPECT_CALL(observer1,
-                OnEvent(ComponentObserver::COMPONENT_UPDATER_SLEEPING, 0))
+    EXPECT_CALL(observer,
+                OnEvent(ServiceObserver::COMPONENT_NOT_UPDATED,
+                        "jebgalgnebhfojomionfpkfelancnnkf"))
+                .Times(1);
+    EXPECT_CALL(observer,
+                OnEvent(ServiceObserver::COMPONENT_NOT_UPDATED,
+                        "abagagagagagagagagagagagagagagag"))
+                .Times(1);
+    EXPECT_CALL(observer,
+                OnEvent(ServiceObserver::COMPONENT_UPDATER_SLEEPING, ""))
                 .Times(1);
   }
 
-  MockComponentObserver observer2;
-  {
-    InSequence seq;
-    EXPECT_CALL(observer2,
-                OnEvent(ComponentObserver::COMPONENT_UPDATER_STARTED, 0))
-                .Times(1);
-    EXPECT_CALL(observer2,
-                OnEvent(ComponentObserver::COMPONENT_NOT_UPDATED, 0))
-                .Times(1);
-    EXPECT_CALL(observer2,
-                OnEvent(ComponentObserver::COMPONENT_UPDATER_SLEEPING, 0))
-                .Times(1);
-    EXPECT_CALL(observer2,
-                OnEvent(ComponentObserver::COMPONENT_NOT_UPDATED, 0))
-                .Times(1);
-    EXPECT_CALL(observer2,
-                OnEvent(ComponentObserver::COMPONENT_UPDATER_SLEEPING, 0))
-                .Times(1);
-  }
-
   EXPECT_TRUE(post_interceptor_->ExpectRequest(new PartialMatch(
       "updatecheck"), test_file("updatecheck_reply_1.xml")));
   EXPECT_TRUE(post_interceptor_->ExpectRequest(new PartialMatch("event")));
   EXPECT_TRUE(post_interceptor_->ExpectRequest(new PartialMatch(
       "updatecheck"), test_file("updatecheck_reply_1.xml")));
 
   get_interceptor_->SetResponse(
       GURL(expected_crx_url),
       test_file("jebgalgnebhfojomionfpkfelancnnkf.crx"));
 
+  component_updater()->AddObserver(&observer);
+
   TestInstaller installer1;
   CrxComponent com1;
-  com1.observer = &observer1;
   RegisterComponent(&com1, kTestComponent_jebg, Version("0.9"), &installer1);
   TestInstaller installer2;
   CrxComponent com2;
-  com2.observer = &observer2;
   RegisterComponent(&com2, kTestComponent_abag, Version("2.2"), &installer2);
 
   test_configurator()->SetLoopCount(2);
   component_updater()->Start();
   RunThreads();
 
   EXPECT_EQ(0, static_cast<TestInstaller*>(com1.installer)->error());
   EXPECT_EQ(1, static_cast<TestInstaller*>(com1.installer)->install_count());
   EXPECT_EQ(0, static_cast<TestInstaller*>(com2.installer)->error());
   EXPECT_EQ(0, static_cast<TestInstaller*>(com2.installer)->install_count());
@@ skipping 98 matching lines @@
   component_updater()->Stop();
 }
 
 // Test that a update check due to an on demand call can cause installs.
 // Here is the timeline:
 //  - First loop: we return a reply that indicates no update, so
 //    nothing happens.
 //  - We make an on demand call.
 //  - This triggers a second loop, which has a reply that triggers an install.
 TEST_F(ComponentUpdaterTest, OnDemandUpdate) {
-  MockComponentObserver observer1;
+  MockServiceObserver observer;
   {
     InSequence seq;
-    EXPECT_CALL(observer1,
-                OnEvent(ComponentObserver::COMPONENT_UPDATER_STARTED, 0))
+    EXPECT_CALL(observer,
+                OnEvent(ServiceObserver::COMPONENT_UPDATER_STARTED, ""))
                 .Times(1);
-    EXPECT_CALL(observer1,
-                OnEvent(ComponentObserver::COMPONENT_NOT_UPDATED, 0))
+    EXPECT_CALL(observer,
+                OnEvent(ServiceObserver::COMPONENT_NOT_UPDATED,
+                        "abagagagagagagagagagagagagagagag"))
                 .Times(1);
-    EXPECT_CALL(observer1,
-                OnEvent(ComponentObserver::COMPONENT_UPDATER_SLEEPING, 0))
+    EXPECT_CALL(observer,
+                OnEvent(ServiceObserver::COMPONENT_NOT_UPDATED,
+                        "jebgalgnebhfojomionfpkfelancnnkf"))
                 .Times(1);
-    EXPECT_CALL(observer1,
-                OnEvent(ComponentObserver::COMPONENT_UPDATER_STARTED, 0))
+    EXPECT_CALL(observer,
+                OnEvent(ServiceObserver::COMPONENT_UPDATER_SLEEPING, ""))
                 .Times(1);
-    EXPECT_CALL(observer1,
-                OnEvent(ComponentObserver::COMPONENT_NOT_UPDATED, 0))
+    EXPECT_CALL(observer,
+                OnEvent(ServiceObserver::COMPONENT_UPDATER_STARTED, ""))
                 .Times(1);
-    EXPECT_CALL(observer1,
-                OnEvent(ComponentObserver::COMPONENT_UPDATER_SLEEPING, 0))
+    EXPECT_CALL(observer,
+                OnEvent(ServiceObserver::COMPONENT_UPDATE_FOUND,
+                        "jebgalgnebhfojomionfpkfelancnnkf"))
+                .Times(1);
+    EXPECT_CALL(observer,
+                OnEvent(ServiceObserver::COMPONENT_NOT_UPDATED,
+                        "abagagagagagagagagagagagagagagag"))
+                .Times(1);
+    EXPECT_CALL(observer,
+                OnEvent(ServiceObserver::COMPONENT_UPDATE_READY,
+                        "jebgalgnebhfojomionfpkfelancnnkf"))
+                .Times(1);
+    EXPECT_CALL(observer,
+                OnEvent(ServiceObserver::COMPONENT_UPDATED,
+                        "jebgalgnebhfojomionfpkfelancnnkf"))
+                .Times(1);
+    EXPECT_CALL(observer,
+                OnEvent(ServiceObserver::COMPONENT_UPDATER_SLEEPING, ""))
                 .Times(1);
   }
 
-  MockComponentObserver observer2;
-  {
-    InSequence seq;
-    EXPECT_CALL(observer2,
-                OnEvent(ComponentObserver::COMPONENT_UPDATER_STARTED, 0))
-                .Times(1);
-    EXPECT_CALL(observer2,
-                OnEvent(ComponentObserver::COMPONENT_NOT_UPDATED, 0))
-                .Times(1);
-    EXPECT_CALL(observer2,
-                OnEvent(ComponentObserver::COMPONENT_UPDATER_SLEEPING, 0))
-                .Times(1);
-    EXPECT_CALL(observer2,
-                OnEvent(ComponentObserver::COMPONENT_UPDATER_STARTED, 0))
-                .Times(1);
-    EXPECT_CALL(observer2,
-                OnEvent(ComponentObserver::COMPONENT_UPDATE_FOUND, 0))
-                .Times(1);
-    EXPECT_CALL(observer2,
-                OnEvent(ComponentObserver::COMPONENT_UPDATE_READY, 0))
-                .Times(1);
-    EXPECT_CALL(observer2,
-                OnEvent(ComponentObserver::COMPONENT_UPDATED, 0))
-                .Times(1);
-    EXPECT_CALL(observer2,
-                OnEvent(ComponentObserver::COMPONENT_UPDATER_SLEEPING, 0))
-                .Times(1);
-  }
-
   EXPECT_TRUE(post_interceptor_->ExpectRequest(new PartialMatch(
       "updatecheck"), test_file("updatecheck_reply_empty")));
 
   get_interceptor_->SetResponse(
       GURL(expected_crx_url),
       test_file("jebgalgnebhfojomionfpkfelancnnkf.crx"));
 
+  component_updater()->AddObserver(&observer);
+
   TestInstaller installer1;
   CrxComponent com1;
-  com1.observer = &observer1;
   RegisterComponent(&com1, kTestComponent_abag, Version("2.2"), &installer1);
   TestInstaller installer2;
   CrxComponent com2;
-  com2.observer = &observer2;
   RegisterComponent(&com2, kTestComponent_jebg, Version("0.9"), &installer2);
 
   // No update normally.
   test_configurator()->SetLoopCount(1);
   component_updater()->Start();
   RunThreads();
   component_updater()->Stop();
 
   EXPECT_EQ(1, post_interceptor_->GetHitCount())
       << post_interceptor_->GetRequestsAsString();
@@ skipping 47 matching lines @@
   test_configurator()->SetOnDemandTime(60 * 60);
   EXPECT_EQ(ComponentUpdateService::kError,
             OnDemandTester::OnDemand(component_updater(),
                                      GetCrxComponentID(com2)));
   // Okay, now reset to 0 for the other tests.
   test_configurator()->SetOnDemandTime(0);
   component_updater()->Stop();
 
   // Test a few error cases. NOTE: We don't have callbacks for
   // when the updates failed yet.
-  EXPECT_TRUE(Mock::VerifyAndClearExpectations(&observer1));
+  EXPECT_TRUE(Mock::VerifyAndClearExpectations(&observer));
   {
     InSequence seq;
-    EXPECT_CALL(observer1,
-                OnEvent(ComponentObserver::COMPONENT_UPDATER_STARTED, 0))
+    EXPECT_CALL(observer,
+                OnEvent(ServiceObserver::COMPONENT_UPDATER_STARTED, ""))
                 .Times(1);
-    EXPECT_CALL(observer1,
-                OnEvent(ComponentObserver::COMPONENT_NOT_UPDATED, 0))
+    EXPECT_CALL(observer,
+                OnEvent(ServiceObserver::COMPONENT_NOT_UPDATED,
+                        "abagagagagagagagagagagagagagagag"))
                 .Times(1);
-    EXPECT_CALL(observer1,
-                OnEvent(ComponentObserver::COMPONENT_UPDATER_SLEEPING, 0))
+    EXPECT_CALL(observer,
+                OnEvent(ServiceObserver::COMPONENT_NOT_UPDATED,
+                        "jebgalgnebhfojomionfpkfelancnnkf"))
                 .Times(1);
-  }
-  EXPECT_TRUE(Mock::VerifyAndClearExpectations(&observer2));
-  {
-    InSequence seq;
-    EXPECT_CALL(observer2,
-                OnEvent(ComponentObserver::COMPONENT_UPDATER_STARTED, 0))
-                .Times(1);
-    EXPECT_CALL(observer2,
-                OnEvent(ComponentObserver::COMPONENT_NOT_UPDATED, 0))
-                .Times(1);
-    EXPECT_CALL(observer2,
-                OnEvent(ComponentObserver::COMPONENT_UPDATER_SLEEPING, 0))
+    EXPECT_CALL(observer,
+                OnEvent(ServiceObserver::COMPONENT_UPDATER_SLEEPING, ""))
                 .Times(1);
   }
 
   // No update: error from no server response
   post_interceptor_->Reset();
   EXPECT_TRUE(post_interceptor_->ExpectRequest(new PartialMatch(
       "updatecheck"), test_file("updatecheck_reply_empty")));
 
   test_configurator()->SetLoopCount(1);
   component_updater()->Start();
   EXPECT_EQ(ComponentUpdateService::kOk,
             OnDemandTester::OnDemand(component_updater(),
                                      GetCrxComponentID(com2)));
   RunThreads();
   component_updater()->Stop();
 
   EXPECT_EQ(1, post_interceptor_->GetHitCount())
       << post_interceptor_->GetRequestsAsString();
   EXPECT_EQ(1, post_interceptor_->GetCount())
       << post_interceptor_->GetRequestsAsString();
 
   // No update: already updated to 1.0 so nothing new
-  EXPECT_TRUE(Mock::VerifyAndClearExpectations(&observer1));
+  EXPECT_TRUE(Mock::VerifyAndClearExpectations(&observer));
   {
     InSequence seq;
-    EXPECT_CALL(observer1,
-                OnEvent(ComponentObserver::COMPONENT_UPDATER_STARTED, 0))
+    EXPECT_CALL(observer,
+                OnEvent(ServiceObserver::COMPONENT_UPDATER_STARTED, ""))
                 .Times(1);
-    EXPECT_CALL(observer1,
-                OnEvent(ComponentObserver::COMPONENT_NOT_UPDATED, 0))
+    EXPECT_CALL(observer,
+                OnEvent(ServiceObserver::COMPONENT_NOT_UPDATED,
+                        "jebgalgnebhfojomionfpkfelancnnkf"))
                 .Times(1);
-    EXPECT_CALL(observer1,
-                OnEvent(ComponentObserver::COMPONENT_UPDATER_SLEEPING, 0))
+    EXPECT_CALL(observer,
+                OnEvent(ServiceObserver::COMPONENT_NOT_UPDATED,
+                        "abagagagagagagagagagagagagagagag"))
                 .Times(1);
-  }
-  EXPECT_TRUE(Mock::VerifyAndClearExpectations(&observer2));
-  {
-    InSequence seq;
-    EXPECT_CALL(observer2,
-                OnEvent(ComponentObserver::COMPONENT_UPDATER_STARTED, 0))
-                .Times(1);
-    EXPECT_CALL(observer2,
-                OnEvent(ComponentObserver::COMPONENT_NOT_UPDATED, 0))
-                .Times(1);
-    EXPECT_CALL(observer2,
-                OnEvent(ComponentObserver::COMPONENT_UPDATER_SLEEPING, 0))
+    EXPECT_CALL(observer,
+                OnEvent(ServiceObserver::COMPONENT_UPDATER_SLEEPING, ""))
                 .Times(1);
   }
 
   post_interceptor_->Reset();
   EXPECT_TRUE(post_interceptor_->ExpectRequest(new PartialMatch(
       "updatecheck"), test_file("updatecheck_reply_1.xml")));
 
   test_configurator()->SetLoopCount(1);
   component_updater()->Start();
   EXPECT_EQ(ComponentUpdateService::kOk,
             OnDemandTester::OnDemand(component_updater(),
                                      GetCrxComponentID(com2)));
   RunThreads();
 
   EXPECT_EQ(1, post_interceptor_->GetHitCount())
       << post_interceptor_->GetRequestsAsString();
   EXPECT_EQ(1, post_interceptor_->GetCount())
       << post_interceptor_->GetRequestsAsString();
 
   component_updater()->Stop();
 }
 
 // Verify that a previously registered component can get re-registered
 // with a different version.
 TEST_F(ComponentUpdaterTest, CheckReRegistration) {
-  MockComponentObserver observer1;
+  MockServiceObserver observer;
   {
     InSequence seq;
-    EXPECT_CALL(observer1,
-                OnEvent(ComponentObserver::COMPONENT_UPDATER_STARTED, 0))
+    EXPECT_CALL(observer,
+                OnEvent(ServiceObserver::COMPONENT_UPDATER_STARTED, ""))
                 .Times(1);
-    EXPECT_CALL(observer1,
-                OnEvent(ComponentObserver::COMPONENT_UPDATE_FOUND, 0))
+    EXPECT_CALL(observer,
+                OnEvent(ServiceObserver::COMPONENT_UPDATE_FOUND,
+                        "jebgalgnebhfojomionfpkfelancnnkf"))
                 .Times(1);
-    EXPECT_CALL(observer1,
-                OnEvent(ComponentObserver::COMPONENT_UPDATE_READY, 0))
+    EXPECT_CALL(observer,
+                OnEvent(ServiceObserver::COMPONENT_NOT_UPDATED,
+                        "abagagagagagagagagagagagagagagag"))
                 .Times(1);
-    EXPECT_CALL(observer1,
-                OnEvent(ComponentObserver::COMPONENT_UPDATED, 0))
+    EXPECT_CALL(observer,
+                OnEvent(ServiceObserver::COMPONENT_UPDATE_READY,
+                        "jebgalgnebhfojomionfpkfelancnnkf"))
                 .Times(1);
-    EXPECT_CALL(observer1,
-                OnEvent(ComponentObserver::COMPONENT_UPDATER_SLEEPING, 0))
+    EXPECT_CALL(observer,
+                OnEvent(ServiceObserver::COMPONENT_UPDATED,
+                        "jebgalgnebhfojomionfpkfelancnnkf"))
                 .Times(1);
-    EXPECT_CALL(observer1,
-                OnEvent(ComponentObserver::COMPONENT_NOT_UPDATED, 0))
+    EXPECT_CALL(observer,
+                OnEvent(ServiceObserver::COMPONENT_UPDATER_SLEEPING, ""))
                 .Times(1);
-    EXPECT_CALL(observer1,
-                OnEvent(ComponentObserver::COMPONENT_UPDATER_SLEEPING, 0))
+    EXPECT_CALL(observer,
+                OnEvent(ServiceObserver::COMPONENT_NOT_UPDATED,
+                        "jebgalgnebhfojomionfpkfelancnnkf"))
+                .Times(1);
+    EXPECT_CALL(observer,
+                OnEvent(ServiceObserver::COMPONENT_NOT_UPDATED,
+                        "abagagagagagagagagagagagagagagag"))
+                .Times(1);
+    EXPECT_CALL(observer,
+                OnEvent(ServiceObserver::COMPONENT_UPDATER_SLEEPING, ""))
                 .Times(1);
   }
 
-  MockComponentObserver observer2;
-  {
-    InSequence seq;
-    EXPECT_CALL(observer2,
-                OnEvent(ComponentObserver::COMPONENT_UPDATER_STARTED, 0))
-                .Times(1);
-    EXPECT_CALL(observer2,
-                OnEvent(ComponentObserver::COMPONENT_NOT_UPDATED, 0))
-                .Times(1);
-    EXPECT_CALL(observer2,
-                OnEvent(ComponentObserver::COMPONENT_UPDATER_SLEEPING, 0))
-                .Times(1);
-    EXPECT_CALL(observer2,
-                OnEvent(ComponentObserver::COMPONENT_NOT_UPDATED, 0))
-                .Times(1);
-    EXPECT_CALL(observer2,
-                OnEvent(ComponentObserver::COMPONENT_UPDATER_SLEEPING, 0))
-                .Times(1);
-  }
-
   EXPECT_TRUE(post_interceptor_->ExpectRequest(new PartialMatch(
       "updatecheck"), test_file("updatecheck_reply_1.xml")));
   EXPECT_TRUE(post_interceptor_->ExpectRequest(new PartialMatch("event")));
   EXPECT_TRUE(post_interceptor_->ExpectRequest(new PartialMatch(
       "updatecheck"), test_file("updatecheck_reply_1.xml")));
 
   get_interceptor_->SetResponse(
       GURL(expected_crx_url),
       test_file("jebgalgnebhfojomionfpkfelancnnkf.crx"));
 
+  component_updater()->AddObserver(&observer);
+
   TestInstaller installer1;
   CrxComponent com1;
-  com1.observer = &observer1;
   RegisterComponent(&com1, kTestComponent_jebg, Version("0.9"), &installer1);
   TestInstaller installer2;
   CrxComponent com2;
-  com2.observer = &observer2;
   RegisterComponent(&com2, kTestComponent_abag, Version("2.2"), &installer2);
 
   // Loop twice to issue two checks: (1) with original 0.9 version, update to
   // 1.0, and do the second check (2) with the updated 1.0 version.
   test_configurator()->SetLoopCount(2);
   component_updater()->Start();
   RunThreads();
 
   EXPECT_EQ(0, static_cast<TestInstaller*>(com1.installer)->error());
   EXPECT_EQ(1, static_cast<TestInstaller*>(com1.installer)->install_count());
@@ skipping 14 matching lines @@
       "<event eventtype=\"3\" eventresult=\"1\"/>"))
       << post_interceptor_->GetRequestsAsString();
   EXPECT_NE(string::npos, post_interceptor_->GetRequests()[2].find(
       "<app appid=\"jebgalgnebhfojomionfpkfelancnnkf\" version=\"1.0\">"
       "<updatecheck /></app>"))
       << post_interceptor_->GetRequestsAsString();
 
   component_updater()->Stop();
 
   // Now re-register, pretending to be an even newer version (2.2)
-  EXPECT_TRUE(Mock::VerifyAndClearExpectations(&observer1));
+  EXPECT_TRUE(Mock::VerifyAndClearExpectations(&observer));
   {
     InSequence seq;
-    EXPECT_CALL(observer1,
-                OnEvent(ComponentObserver::COMPONENT_UPDATER_STARTED, 0))
+    EXPECT_CALL(observer,
+                OnEvent(ServiceObserver::COMPONENT_UPDATER_STARTED, ""))
                 .Times(1);
-    EXPECT_CALL(observer1,
-                OnEvent(ComponentObserver::COMPONENT_NOT_UPDATED, 0))
+    EXPECT_CALL(observer,
+                OnEvent(ServiceObserver::COMPONENT_NOT_UPDATED,
+                        "jebgalgnebhfojomionfpkfelancnnkf"))
                 .Times(1);
-    EXPECT_CALL(observer1,
-                OnEvent(ComponentObserver::COMPONENT_UPDATER_SLEEPING, 0))
+    EXPECT_CALL(observer,
+                OnEvent(ServiceObserver::COMPONENT_NOT_UPDATED,
+                        "abagagagagagagagagagagagagagagag"))
+                .Times(1);
+    EXPECT_CALL(observer,
+                OnEvent(ServiceObserver::COMPONENT_UPDATER_SLEEPING, ""))
                 .Times(1);
   }
 
-  EXPECT_TRUE(Mock::VerifyAndClearExpectations(&observer2));
-  {
-    InSequence seq;
-    EXPECT_CALL(observer2,
-                OnEvent(ComponentObserver::COMPONENT_UPDATER_STARTED, 0))
-                .Times(1);
-    EXPECT_CALL(observer2,
-                OnEvent(ComponentObserver::COMPONENT_NOT_UPDATED, 0))
-                .Times(1);
-    EXPECT_CALL(observer2,
-                OnEvent(ComponentObserver::COMPONENT_UPDATER_SLEEPING, 0))
-                .Times(1);
-  }
-
   post_interceptor_->Reset();
   EXPECT_TRUE(post_interceptor_->ExpectRequest(new PartialMatch(
       "updatecheck"), test_file("updatecheck_reply_1.xml")));
 
   TestInstaller installer3;
   EXPECT_EQ(ComponentUpdateService::kReplaced,
             RegisterComponent(&com1,
                               kTestComponent_jebg,
                               Version("2.2"),
                               &installer3));
@@ skipping 356 matching lines @@
     virtual void Cancel() OVERRIDE { CHECK(false); }
     virtual void CancelAndIgnore() OVERRIDE { CHECK(false); }
     virtual void CancelWithError(int error_code) OVERRIDE { CHECK(false); }
     virtual void Resume() OVERRIDE { CHECK(false); }
   } controller;
 
   delete RequestTestResourceThrottle(cus, &controller, crx_id);
 }
 
 TEST_F(ComponentUpdaterTest, ResourceThrottleDeletedNoUpdate) {
-  MockComponentObserver observer;
-  EXPECT_CALL(observer,
-              OnEvent(ComponentObserver::COMPONENT_UPDATER_STARTED, 0))
-              .Times(1);
-  EXPECT_CALL(observer,
-              OnEvent(ComponentObserver::COMPONENT_UPDATER_SLEEPING, 0))
-              .Times(1);
-  EXPECT_CALL(observer,
-              OnEvent(ComponentObserver::COMPONENT_NOT_UPDATED, 0))
-              .Times(1);
+  MockServiceObserver observer;
+  {
+    InSequence seq;
+    EXPECT_CALL(observer,
+                OnEvent(ServiceObserver::COMPONENT_UPDATER_STARTED, ""))
+                .Times(1);
+    EXPECT_CALL(observer,
+                OnEvent(ServiceObserver::COMPONENT_NOT_UPDATED,
+                        "abagagagagagagagagagagagagagagag"))
+                .Times(1);
+    EXPECT_CALL(observer,
+                OnEvent(ServiceObserver::COMPONENT_UPDATER_SLEEPING, ""))
+                .Times(1);
+  }
 
   EXPECT_TRUE(post_interceptor_->ExpectRequest(new PartialMatch(
       "updatecheck"), test_file("updatecheck_reply_1.xml")));
 
   TestInstaller installer;
   CrxComponent com;
-  com.observer = &observer;
+  component_updater()->AddObserver(&observer);
   EXPECT_EQ(ComponentUpdateService::kOk,
             RegisterComponent(&com,
                               kTestComponent_abag,
                               Version("1.1"),
                               &installer));
   // The following two calls ensure that we don't do an update check via the
   // timer, so the only update check should be the on-demand one.
   test_configurator()->SetInitialDelay(1000000);
   test_configurator()->SetRecheckTime(1000000);
   test_configurator()->SetLoopCount(1);
@@ skipping 48 matching lines @@
   }
 
   private:
   void ResumeCalled() { ++resume_called_; }
 
   content::ResourceThrottle* throttle_;
   int resume_called_;
 };
 
 TEST_F(ComponentUpdaterTest, ResourceThrottleLiveNoUpdate) {
-  MockComponentObserver observer;
-  EXPECT_CALL(observer,
-              OnEvent(ComponentObserver::COMPONENT_UPDATER_STARTED, 0))
-              .Times(1);
-  EXPECT_CALL(observer,
-              OnEvent(ComponentObserver::COMPONENT_UPDATER_SLEEPING, 0))
-              .Times(1);
-  EXPECT_CALL(observer,
-              OnEvent(ComponentObserver::COMPONENT_NOT_UPDATED, 0))
-              .Times(1);
+  MockServiceObserver observer;
+  {
+    InSequence seq;
+    EXPECT_CALL(observer,
+                OnEvent(ServiceObserver::COMPONENT_UPDATER_STARTED, ""))
+                .Times(1);
+    EXPECT_CALL(observer,
+                OnEvent(ServiceObserver::COMPONENT_NOT_UPDATED,
+                        "abagagagagagagagagagagagagagagag"))
+                .Times(1);
+    EXPECT_CALL(observer,
+                OnEvent(ServiceObserver::COMPONENT_UPDATER_SLEEPING, ""))
+                .Times(1);
+  }
 
   EXPECT_TRUE(post_interceptor_->ExpectRequest(new PartialMatch(
       "updatecheck"), test_file("updatecheck_reply_1.xml")));
 
   TestInstaller installer;
   CrxComponent com;
-  com.observer = &observer;
+  component_updater()->AddObserver(&observer);
   EXPECT_EQ(ComponentUpdateService::kOk,
             RegisterComponent(&com,
                               kTestComponent_abag,
                               Version("1.1"),
                               &installer));
   // The following two calls ensure that we don't do an update check via the
   // timer, so the only update check should be the on-demand one.
   test_configurator()->SetInitialDelay(1000000);
   test_configurator()->SetRecheckTime(1000000);
   test_configurator()->SetLoopCount(1);
@@ skipping 15 matching lines @@
 
   RunThreads();
 
   EXPECT_EQ(1, post_interceptor_->GetHitCount());
   EXPECT_EQ(0, static_cast<TestInstaller*>(com.installer)->error());
   EXPECT_EQ(0, static_cast<TestInstaller*>(com.installer)->install_count());
 
   component_updater()->Stop();
 }
 
+// Tests adding and removing observers.
+TEST_F(ComponentUpdaterTest, Observer) {
+  MockServiceObserver observer1, observer2;
+
+  // Expect that two observers see the events.
+  {
+    InSequence seq;
+    EXPECT_CALL(observer1,
+                OnEvent(ServiceObserver::COMPONENT_UPDATER_STARTED, ""))
+                .Times(1);
+    EXPECT_CALL(observer2,
+                OnEvent(ServiceObserver::COMPONENT_UPDATER_STARTED, ""))
+                .Times(1);
+    EXPECT_CALL(observer1,
+                OnEvent(ServiceObserver::COMPONENT_NOT_UPDATED,
+                        "abagagagagagagagagagagagagagagag"))
+                .Times(1);
+    EXPECT_CALL(observer2,
+                OnEvent(ServiceObserver::COMPONENT_NOT_UPDATED,
+                        "abagagagagagagagagagagagagagagag"))
+                .Times(1);
+    EXPECT_CALL(observer1,
+                OnEvent(ServiceObserver::COMPONENT_UPDATER_SLEEPING, ""))
+                .Times(1);
+    EXPECT_CALL(observer2,
+                OnEvent(ServiceObserver::COMPONENT_UPDATER_SLEEPING, ""))
+                .Times(1);
+  }
+
+  EXPECT_TRUE(post_interceptor_->ExpectRequest(new PartialMatch(
+      "updatecheck"), test_file("updatecheck_reply_1.xml")));
+
+  component_updater()->AddObserver(&observer1);
+  component_updater()->AddObserver(&observer2);
+
+  TestInstaller installer;
+  CrxComponent com;
+  EXPECT_EQ(ComponentUpdateService::kOk,
+            RegisterComponent(&com,
+                              kTestComponent_abag,
+                              Version("1.1"),
+                              &installer));
+  test_configurator()->SetLoopCount(1);
+  component_updater()->Start();
+  RunThreads();
+
+  // After removing the first observer, it's only the second observer that
+  // gets the events.
+  EXPECT_TRUE(Mock::VerifyAndClearExpectations(&observer1));
+  EXPECT_TRUE(Mock::VerifyAndClearExpectations(&observer2));
+  {
+    InSequence seq;
+    EXPECT_CALL(observer2,
+                OnEvent(ServiceObserver::COMPONENT_UPDATER_STARTED, ""))
+                .Times(1);
+    EXPECT_CALL(observer2,
+                OnEvent(ServiceObserver::COMPONENT_NOT_UPDATED,
+                        "abagagagagagagagagagagagagagagag"))
+                .Times(1);
+    EXPECT_CALL(observer2,
+                OnEvent(ServiceObserver::COMPONENT_UPDATER_SLEEPING, ""))
+                .Times(1);
+  }
+
+  component_updater()->RemoveObserver(&observer1);
+
+  test_configurator()->SetLoopCount(1);
+  component_updater()->Start();
+  RunThreads();
+
+  // Both observers are removed and no one gets the events.
+  EXPECT_TRUE(Mock::VerifyAndClearExpectations(&observer1));
+  EXPECT_TRUE(Mock::VerifyAndClearExpectations(&observer2));
+  component_updater()->RemoveObserver(&observer2);
+
+  test_configurator()->SetLoopCount(1);
+  component_updater()->Start();
+  RunThreads();
+
+  component_updater()->Stop();
+}
 
 }  // namespace component_updater
-