Add a scoper object for URLFetcher::Factory

content/test/test_url_fetcher_factory.h

 // Copyright (c) 2011 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.
 
-#ifndef CONTENT_COMMON_TEST_URL_FETCHER_FACTORY_H_
-#define CONTENT_COMMON_TEST_URL_FETCHER_FACTORY_H_
+#ifndef CONTENT_TEST_TEST_URL_FETCHER_FACTORY_H_
+#define CONTENT_TEST_TEST_URL_FETCHER_FACTORY_H_
 #pragma once
 
 #include <list>
 #include <map>
 #include <string>
 #include <utility>
 
+#include "base/threading/non_thread_safe.h"
 #include "content/common/url_fetcher.h"
+#include "googleurl/src/gurl.h"
 #include "net/url_request/url_request_status.h"
-#include "googleurl/src/gurl.h"
+
+// Changes URLFetcher's Factory for the lifetime of the object.
+// Note that this scoper cannot be nested (to make it even harder to misuse).
+class ScopedURLFetcherFactory : public base::NonThreadSafe {
+ public:
+  explicit ScopedURLFetcherFactory(URLFetcher::Factory* factory);
+  virtual ~ScopedURLFetcherFactory();
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ScopedURLFetcherFactory);
+};
 
 // TestURLFetcher and TestURLFetcherFactory are used for testing consumers of
 // URLFetcher. TestURLFetcherFactory is a URLFetcher::Factory that creates
 // TestURLFetchers. TestURLFetcher::Start is overriden to do nothing. It is
 // expected that you'll grab the delegate from the TestURLFetcher and invoke
 // the callback method when appropriate. In this way it's easy to mock a
 // URLFetcher.
 // Typical usage:
 //   // TestURLFetcher requires a MessageLoop:
 //   MessageLoopForUI message_loop;
 //   // And io_thread to release URLRequestContextGetter in URLFetcher::Core.
 //   BrowserThread io_thread(BrowserThread::IO, &message_loop);
-//   // Create and register factory.
+//   // Create factory (it automatically sets itself as URLFetcher's factory).
 //   TestURLFetcherFactory factory;
-//   URLFetcher::set_factory(&factory);
 //   // Do something that triggers creation of a URLFetcher.
 //   TestURLFetcher* fetcher = factory.GetFetcherByID(expected_id);
 //   DCHECK(fetcher);
 //   // Notify delegate with whatever data you want.
 //   fetcher->delegate()->OnURLFetchComplete(...);
 //   // Make sure consumer of URLFetcher does the right thing.
 //   ...
-//   // Reset factory.
-//   URLFetcher::set_factory(NULL);
 //
 // Note: if you don't know when your request objects will be created you
 // might want to use the FakeUrlFetcher and FakeUrlFetcherFactory classes
 // below.
 
 class TestURLFetcher : public URLFetcher {
  public:
   TestURLFetcher(int id,
                  const GURL& url,
                  RequestType request_type,
@@ skipping 60 matching lines @@
   net::URLRequestStatus fake_status_;
   int fake_response_code_;
   std::string fake_response_string_;
   FilePath fake_response_file_path_;
 
   DISALLOW_COPY_AND_ASSIGN(TestURLFetcher);
 };
 
 // Simple URLFetcher::Factory method that creates TestURLFetchers. All fetchers
 // are registered in a map by the id passed to the create method.
-class TestURLFetcherFactory : public URLFetcher::Factory {
+class TestURLFetcherFactory : public URLFetcher::Factory,
+                              public ScopedURLFetcherFactory {
  public:
   TestURLFetcherFactory();
   virtual ~TestURLFetcherFactory();
 
   virtual URLFetcher* CreateURLFetcher(int id,
                                        const GURL& url,
                                        URLFetcher::RequestType request_type,
                                        URLFetcher::Delegate* d);
   TestURLFetcher* GetFetcherByID(int id) const;
   void RemoveFetcherFromMap(int id);
@@ skipping 18 matching lines @@
 //
 // This class is not thread-safe.  You should not call SetFakeResponse or
 // ClearFakeResponse at the same time you call CreateURLFetcher.  However, it is
 // OK to start URLFetcher objects while setting or clearning fake responses
 // since already created URLFetcher objects will not be affected by any changes
 // made to the fake responses (once a URLFetcher object is created you cannot
 // change its fake response).
 //
 // Example usage:
 //  FakeURLFetcherFactory factory;
-//  URLFetcher::set_factory(&factory);
 //
 //  // You know that class SomeService will request url http://a.com/ and you
 //  // want to test the service class by returning an error.
 //  factory.SetFakeResponse("http://a.com/", "", false);
 //  // But if the service requests http://b.com/asdf you want to respond with
 //  // a simple html page and an HTTP/200 code.
 //  factory.SetFakeResponse("http://b.com/asdf",
 //                          "<html><body>hello world</body></html>",
 //                          true);
 //
 //  SomeService service;
 //  service.Run();  // Will eventually request these two URLs.
 
-class FakeURLFetcherFactory : public URLFetcher::Factory {
+class FakeURLFetcherFactory : public URLFetcher::Factory,
+                              public ScopedURLFetcherFactory {
  public:
   FakeURLFetcherFactory();
   // FakeURLFetcherFactory that will delegate creating URLFetcher for unknown
   // url to the given factory.
   explicit FakeURLFetcherFactory(URLFetcher::Factory* default_factory);
   virtual ~FakeURLFetcherFactory();
 
   // If no fake response is set for the given URL this method will delegate the
   // call to |default_factory_| if it is not NULL, or return NULL if it is
   // NULL.
@@ skipping 32 matching lines @@
   virtual ~URLFetcherFactory();
 
   // This method will create a real URLFetcher.
   virtual URLFetcher* CreateURLFetcher(int id,
                                        const GURL& url,
                                        URLFetcher::RequestType request_type,
                                        URLFetcher::Delegate* d);
 
 };
 
-#endif  // CONTENT_COMMON_TEST_URL_FETCHER_FACTORY_H_
+#endif  // CONTENT_TEST_TEST_URL_FETCHER_FACTORY_H_