Get rid of ResourceDispatcherHost check in safe_manifest_parser.cc. Single process mode is now hand…

chrome/browser/extensions/updater/extension_updater_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 <list>
 #include <map>
 #include <set>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 32 matching lines @@
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_manifest_constants.h"
 #include "chrome/common/omaha_query_params/omaha_query_params.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
-#include "content/public/test/test_browser_thread.h"
+#include "content/public/browser/render_process_host.h"
+#include "content/public/test/test_browser_thread_bundle.h"
+#include "content/public/test/test_utils.h"
 #include "extensions/common/id_util.h"
 #include "libxml/globals.h"
 #include "net/base/backoff_entry.h"
 #include "net/base/escape.h"
 #include "net/base/load_flags.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_request_status.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/login/user_manager.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/chromeos/settings/device_settings_service.h"
 #endif
 
 using base::Time;
 using base::TimeDelta;
 using content::BrowserThread;
 using testing::DoAll;
+using testing::InvokeWithoutArgs;
 using testing::Mock;
 using testing::Return;
 using testing::SetArgPointee;
 using testing::_;
 
 namespace extensions {
 
 typedef ExtensionDownloaderDelegate::Error Error;
 typedef ExtensionDownloaderDelegate::PingResult PingResult;
 
@@ skipping 51 matching lines @@
                                                  const std::string&,
                                                  const std::string&,
                                                  const PingResult&,
                                                  const std::set<int>&));
   MOCK_METHOD2(GetPingDataForExtension,
                bool(const std::string&, ManifestFetchData::PingData*));
   MOCK_METHOD1(GetUpdateUrlData, std::string(const std::string&));
   MOCK_METHOD1(IsExtensionPending, bool(const std::string&));
   MOCK_METHOD2(GetExtensionExistingVersion,
                bool(const std::string&, std::string*));
+
+  void Wait() {
+    scoped_refptr<content::MessageLoopRunner> runner =
+        new content::MessageLoopRunner;
+    quit_closure_ = runner->QuitClosure();
+    runner->Run();
+    quit_closure_.Reset();
+  }
+
+  void Quit() {
+    quit_closure_.Run();
+  }
+
+ private:
+  base::Closure quit_closure_;
 };
 
 const int kNotificationsObserved[] = {
   chrome::NOTIFICATION_EXTENSION_UPDATING_STARTED,
   chrome::NOTIFICATION_EXTENSION_UPDATE_FOUND,
 };
 
 // A class that observes the notifications sent by the ExtensionUpdater and
 // the ExtensionDownloader.
 class NotificationsObserver : public content::NotificationObserver {
@@ skipping 15 matching lines @@
     }
   }
 
   size_t StartedCount() { return count_[0]; }
   size_t UpdatedCount() { return count_[1]; }
 
   bool Updated(const std::string& id) {
     return updated_.find(id) != updated_.end();
   }
 
+  void Wait() {
+    scoped_refptr<content::MessageLoopRunner> runner =
+        new content::MessageLoopRunner;
+    quit_closure_ = runner->QuitClosure();
+    runner->Run();
+    quit_closure_.Reset();
+  }
+
  private:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE {
+    if (!quit_closure_.is_null())
+      quit_closure_.Run();
     for (size_t i = 0; i < arraysize(kNotificationsObserved); ++i) {
       if (kNotificationsObserved[i] == type) {
         count_[i]++;
         if (type == chrome::NOTIFICATION_EXTENSION_UPDATE_FOUND) {
           updated_.insert(
               content::Details<UpdateDetails>(details)->id);
         }
         return;
       }
     }
     NOTREACHED();
   }
 
   content::NotificationRegistrar registrar_;
   size_t count_[arraysize(kNotificationsObserved)];
   std::set<std::string> updated_;
+  base::Closure quit_closure_;
 
   DISALLOW_COPY_AND_ASSIGN(NotificationsObserver);
 };
 
 }  // namespace
 
 // Base class for further specialized test classes.
 class MockService : public TestExtensionService {
  public:
   explicit MockService(TestExtensionPrefs* prefs)
@@ skipping 252 matching lines @@
   std::string decoded = net::UnescapeURLComponent(
       params["x"], net::UnescapeRule::URL_SPECIAL_CHARS);
   ExtractParameters(decoded, result);
 }
 
 // All of our tests that need to use private APIs of ExtensionUpdater live
 // inside this class (which is a friend to ExtensionUpdater).
 class ExtensionUpdaterTest : public testing::Test {
  public:
   ExtensionUpdaterTest()
-      : ui_thread_(BrowserThread::UI, &loop_),
-        file_thread_(BrowserThread::FILE, &loop_),
-        io_thread_(BrowserThread::IO, &loop_) {
+      : test_browser_thread_bundle_(
+            content::TestBrowserThreadBundle::IO_MAINLOOP) {
   }
 
   virtual ~ExtensionUpdaterTest() {
   }
 
   virtual void SetUp() OVERRIDE {
-    prefs_.reset(new TestExtensionPrefs(loop_.message_loop_proxy().get()));
+    prefs_.reset(new TestExtensionPrefs(base::MessageLoopProxy::current()));
+    content::RenderProcessHost::SetRunRendererInProcess(true);
   }
 
   virtual void TearDown() OVERRIDE {
     // Some tests create URLRequestContextGetters, whose destruction must run
     // on the IO thread. Make sure the IO loop spins before shutdown so that
     // those objects are released.
     RunUntilIdle();
     prefs_.reset();
+    content::RenderProcessHost::SetRunRendererInProcess(false);
   }
 
   void RunUntilIdle() {
     prefs_->pref_service()->CommitPendingWrite();
-    loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
   }
 
   void SimulateTimerFired(ExtensionUpdater* updater) {
     EXPECT_TRUE(updater->timer_.IsRunning());
     updater->timer_.Stop();
     updater->TimerFired();
   }
 
   // Adds a Result with the given data to results.
   void AddParseResult(const std::string& id,
@@ skipping 340 matching lines @@
     fetcher->delegate()->OnURLFetchComplete(fetcher);
     RunUntilIdle();
     Mock::VerifyAndClearExpectations(&delegate);
 
     // The second fetch gets invalid data.
     const std::string kInvalidXml = "invalid xml";
     fetcher = factory.GetFetcherByID(ExtensionDownloader::kManifestFetcherId);
     EXPECT_TRUE(fetcher != NULL && fetcher->delegate() != NULL);
     EXPECT_TRUE(fetcher->GetLoadFlags() == kExpectedLoadFlags);
     EXPECT_CALL(delegate, OnExtensionDownloadFailed(
-        "2222", ExtensionDownloaderDelegate::MANIFEST_INVALID, _, _));
+        "2222", ExtensionDownloaderDelegate::MANIFEST_INVALID, _, _))
+        .WillOnce(InvokeWithoutArgs(&delegate,
+                                    &MockExtensionDownloaderDelegate::Quit));
     fetcher->set_url(kUpdateUrl);
     fetcher->set_status(net::URLRequestStatus());
     fetcher->set_response_code(200);
     fetcher->SetResponseString(kInvalidXml);
     fetcher->delegate()->OnURLFetchComplete(fetcher);
-    RunUntilIdle();
+    delegate.Wait();
     Mock::VerifyAndClearExpectations(&delegate);
 
     // The third fetcher doesn't have an update available.
     const std::string kNoUpdate =
         "<?xml version='1.0' encoding='UTF-8'?>"
         "<gupdate xmlns='http://www.google.com/update2/response'"
         "                protocol='2.0'>"
         " <app appid='3333'>"
         "  <updatecheck codebase='http://example.com/extension_3.0.0.0.crx'"
         "               version='3.0.0.0' prodversionmin='3.0.0.0' />"
         " </app>"
         "</gupdate>";
     fetcher = factory.GetFetcherByID(ExtensionDownloader::kManifestFetcherId);
     EXPECT_TRUE(fetcher != NULL && fetcher->delegate() != NULL);
     EXPECT_TRUE(fetcher->GetLoadFlags() == kExpectedLoadFlags);
     EXPECT_CALL(delegate, IsExtensionPending("3333")).WillOnce(Return(false));
     EXPECT_CALL(delegate, GetExtensionExistingVersion("3333", _))
         .WillOnce(DoAll(SetArgPointee<1>("3.0.0.0"),
                         Return(true)));
     EXPECT_CALL(delegate, OnExtensionDownloadFailed(
-        "3333", ExtensionDownloaderDelegate::NO_UPDATE_AVAILABLE, _, _));
+        "3333", ExtensionDownloaderDelegate::NO_UPDATE_AVAILABLE, _, _))
+        .WillOnce(InvokeWithoutArgs(&delegate,
+                                    &MockExtensionDownloaderDelegate::Quit));
     fetcher->set_url(kUpdateUrl);
     fetcher->set_status(net::URLRequestStatus());
     fetcher->set_response_code(200);
     fetcher->SetResponseString(kNoUpdate);
     fetcher->delegate()->OnURLFetchComplete(fetcher);
-    RunUntilIdle();
+    delegate.Wait();
     Mock::VerifyAndClearExpectations(&delegate);
 
     // The last fetcher has an update.
     const std::string kUpdateAvailable =
         "<?xml version='1.0' encoding='UTF-8'?>"
         "<gupdate xmlns='http://www.google.com/update2/response'"
         "                protocol='2.0'>"
         " <app appid='4444'>"
         "  <updatecheck codebase='http://example.com/extension_1.2.3.4.crx'"
         "               version='4.0.42.0' prodversionmin='4.0.42.0' />"
         " </app>"
         "</gupdate>";
     fetcher = factory.GetFetcherByID(ExtensionDownloader::kManifestFetcherId);
     EXPECT_TRUE(fetcher != NULL && fetcher->delegate() != NULL);
     EXPECT_TRUE(fetcher->GetLoadFlags() == kExpectedLoadFlags);
     EXPECT_CALL(delegate, IsExtensionPending("4444")).WillOnce(Return(false));
     EXPECT_CALL(delegate, GetExtensionExistingVersion("4444", _))
         .WillOnce(DoAll(SetArgPointee<1>("4.0.0.0"),
                         Return(true)));
     fetcher->set_url(kUpdateUrl);
     fetcher->set_status(net::URLRequestStatus());
     fetcher->set_response_code(200);
     fetcher->SetResponseString(kUpdateAvailable);
     fetcher->delegate()->OnURLFetchComplete(fetcher);
-    RunUntilIdle();
+    observer.Wait();
     Mock::VerifyAndClearExpectations(&delegate);
 
     // Verify that the downloader decided to update this extension.
     EXPECT_EQ(1u, observer.UpdatedCount());
     EXPECT_TRUE(observer.Updated("4444"));
   }
 
   void TestManifestRetryDownloading() {
     net::TestURLFetcherFactory factory;
     net::TestURLFetcher* fetcher = NULL;
@@ skipping 377 matching lines @@
   // on the delta between now and the last ping time (or in the case of active
   // pings, that delta plus whether the app has been active).
   void TestGalleryRequests(int rollcall_ping_days,
                            int active_ping_days,
                            bool active_bit,
                            bool expect_brand_code) {
     net::TestURLFetcherFactory factory;
 
     // Set up 2 mock extensions, one with a google.com update url and one
     // without.
-    prefs_.reset(new TestExtensionPrefs(loop_.message_loop_proxy().get()));
+    prefs_.reset(new TestExtensionPrefs(base::MessageLoopProxy::current()));
     ServiceForManifestTests service(prefs_.get());
     ExtensionList tmp;
     GURL url1("http://clients2.google.com/service/update2/crx");
     GURL url2("http://www.somewebsite.com");
     service.CreateTestExtensions(1, 1, &tmp, &url1.possibly_invalid_spec(),
                                  Manifest::INTERNAL);
     service.CreateTestExtensions(2, 1, &tmp, &url2.possibly_invalid_spec(),
                                  Manifest::INTERNAL);
     EXPECT_EQ(2u, tmp.size());
     service.set_extensions(tmp);
@@ skipping 139 matching lines @@
         service.extension_prefs()->LastPingDay(extension->id());
     EXPECT_FALSE(last_ping_day.is_null());
     int64 seconds_diff = (Time::Now() - last_ping_day).InSeconds();
     EXPECT_LT(seconds_diff - results.daystart_elapsed_seconds, 5);
   }
 
  protected:
   scoped_ptr<TestExtensionPrefs> prefs_;
 
  private:
-  base::MessageLoop loop_;
-  content::TestBrowserThread ui_thread_;
-  content::TestBrowserThread file_thread_;
-  content::TestBrowserThread io_thread_;
+  content::TestBrowserThreadBundle test_browser_thread_bundle_;
 
 #if defined OS_CHROMEOS
   chromeos::ScopedTestDeviceSettingsService test_device_settings_service_;
   chromeos::ScopedTestCrosSettings test_cros_settings_;
   chromeos::ScopedTestUserManager test_user_manager_;
 #endif
 };
 
 // Because we test some private methods of ExtensionUpdater, it's easier for the
 // actual test code to live in ExtenionUpdaterTest methods instead of TEST_F
@@ skipping 243 matching lines @@
 // -prodversionmin (shouldn't update if browser version too old)
 // -manifests & updates arriving out of order / interleaved
 // -malformed update url (empty, file://, has query, has a # fragment, etc.)
 // -An extension gets uninstalled while updates are in progress (so it doesn't
 //  "come back from the dead")
 // -An extension gets manually updated to v3 while we're downloading v2 (ie
 //  you don't get downgraded accidentally)
 // -An update manifest mentions multiple updates
 
 }  // namespace extensions