Componentize component_updater: Break content/ dependency for rest of component_updater tests.

components/component_updater/test/url_request_post_interceptor.h

 // 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.
 
 #ifndef CHROME_BROWSER_COMPONENT_UPDATER_TEST_URL_REQUEST_POST_INTERCEPTOR_H_
 #define CHROME_BROWSER_COMPONENT_UPDATER_TEST_URL_REQUEST_POST_INTERCEPTOR_H_
 
 #include <map>
 #include <queue>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/basictypes.h"
+#include "base/memory/ref_counted.h"
 #include "base/synchronization/lock.h"
 #include "url/gurl.h"
 
 namespace base {
 class FilePath;
+class SequencedTaskRunner;
 }
 
 namespace net {
 class URLRequest;
 }
 
 namespace component_updater {
 
 // component 1 has extension id "jebgalgnebhfojomionfpkfelancnnkf", and
 // the RSA public key the following hash:
@@ skipping 55 matching lines @@
 
   // Resets the state of the interceptor so that new expectations can be set.
   void Reset();
 
   class Delegate;
 
  private:
   friend class URLRequestPostInterceptorFactory;
   typedef std::pair<const RequestMatcher*, std::string> Expectation;
 
-  explicit URLRequestPostInterceptor(const GURL& url);
+  explicit URLRequestPostInterceptor(

[Sorin Jianu, 2014/08/27 17:36:02]

In general, explicit is used for one param ctor in C++03.

[tommycli, 2014/08/27 17:59:22]

Done.

+      const GURL& url,
+      const scoped_refptr<base::SequencedTaskRunner>& io_task_runner);
   ~URLRequestPostInterceptor();
 
   void ClearExpectations();
   const GURL url_;
+  scoped_refptr<base::SequencedTaskRunner> io_task_runner_;
 
   mutable base::Lock interceptor_lock_;
   mutable int hit_count_;
   mutable std::vector<std::string> requests_;
   mutable std::queue<Expectation> expectations_;
 
   DISALLOW_COPY_AND_ASSIGN(URLRequestPostInterceptor);
 };
 
 class URLRequestPostInterceptorFactory {
  public:
-  URLRequestPostInterceptorFactory(const std::string& scheme,
-                                   const std::string& hostname);
+  URLRequestPostInterceptorFactory(
+      const std::string& scheme,
+      const std::string& hostname,
+      const scoped_refptr<base::SequencedTaskRunner>& io_task_runner);
   ~URLRequestPostInterceptorFactory();
 
   // Creates an interceptor object for the specified url path. Returns NULL
   // in case of errors or a valid interceptor object otherwise. The caller
   // does not own the returned object.
   URLRequestPostInterceptor* CreateInterceptor(const base::FilePath& filepath);
 
  private:
   const std::string scheme_;
   const std::string hostname_;
+  scoped_refptr<base::SequencedTaskRunner> io_task_runner_;
 
   // After creation, |delegate_| lives on the IO thread and it is owned by
   // a URLRequestFilter after registration. A task to unregister it and
   // implicitly destroy it is posted from ~URLRequestPostInterceptorFactory().
   URLRequestPostInterceptor::Delegate* delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(URLRequestPostInterceptorFactory);
 };
 
 // Intercepts HTTP POST requests sent to "localhost2".
 class InterceptorFactory : public URLRequestPostInterceptorFactory {
  public:
-  InterceptorFactory();
+  InterceptorFactory(

[Sorin Jianu, 2014/08/27 17:36:02]

explicit

[tommycli, 2014/08/27 17:59:22]

Done.

+      const scoped_refptr<base::SequencedTaskRunner>& io_task_runner);
   ~InterceptorFactory();
 
   URLRequestPostInterceptor* CreateInterceptor();
 
  private:
   DISALLOW_COPY_AND_ASSIGN(InterceptorFactory);
 };
 
 class PartialMatch : public URLRequestPostInterceptor::RequestMatcher {
  public:
   explicit PartialMatch(const std::string& expected) : expected_(expected) {}
   virtual bool Match(const std::string& actual) const OVERRIDE;
 
  private:
   const std::string expected_;
 
   DISALLOW_COPY_AND_ASSIGN(PartialMatch);
 };
 
 }  // namespace component_updater
 
 #endif  // CHROME_BROWSER_COMPONENT_UPDATER_TEST_URL_REQUEST_POST_INTERCEPTOR_H_