JobController 1: Adding a new class HttpStreamFactoryImpl::JobController

net/http/http_stream_factory_test_util.h

+// Copyright (c) 2016 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 NET_HTTP_HTTP_STREAM_FACTORY_TEST_UTIL_H_
+#define NET_HTTP_HTTP_STREAM_FACTORY_TEST_UTIL_H_
+
+#include "base/memory/ptr_util.h"
+#include "net/http/http_stream.h"
+#include "net/http/http_stream_factory.h"
+#include "net/http/http_stream_factory_impl.h"
+#include "net/http/http_stream_factory_impl_job.h"
+#include "net/http/http_stream_factory_impl_job_controller.h"
+#include "net/proxy/proxy_info.h"
+#include "net/proxy/proxy_service.h"
+#include "net/spdy/spdy_test_util_common.h"
+#include "testing/gmock/include/gmock/gmock.h"
+
+namespace net {
+
+// This delegate does nothing when called.
+class TestHttpStreamRequestDelegate : public HttpStreamRequest::Delegate {

[Ryan Hamilton, 2016/06/06 17:57:32]

Since these classes MOCK_ the various methods, instead of providing some sort of
actual implementation, I think they should be called MockFoo.

[Zhongyi Shi, 2016/06/06 22:50:56]

Done.

+ public:
+  TestHttpStreamRequestDelegate();
+
+  ~TestHttpStreamRequestDelegate() override;
+
+  MOCK_METHOD3(OnStreamReady,
+               void(const SSLConfig& used_ssl_config,
+                    const ProxyInfo& used_proxy_info,
+                    HttpStream* stream));
+
+  void OnBidirectionalStreamImplReady(
+      const SSLConfig& used_ssl_config,
+      const ProxyInfo& used_proxy_info,
+      BidirectionalStreamImpl* stream) override {}
+
+  void OnWebSocketHandshakeStreamReady(
+      const SSLConfig& used_ssl_config,
+      const ProxyInfo& used_proxy_info,
+      WebSocketHandshakeStreamBase* stream) override {}
+
+  MOCK_METHOD3(OnStreamFailed,
+               void(int status,
+                    const SSLConfig& used_ssl_config,
+                    SSLFailureState ssl_failure_state));
+
+  MOCK_METHOD3(OnCertificateError,
+               void(int status,
+                    const SSLConfig& used_ssl_config,
+                    const SSLInfo& ssl_info));
+
+  MOCK_METHOD4(OnNeedsProxyAuth,
+               void(const HttpResponseInfo& proxy_response,
+                    const SSLConfig& used_ssl_config,
+                    const ProxyInfo& used_proxy_info,
+                    HttpAuthController* auth_controller));
+
+  MOCK_METHOD2(OnNeedsClientAuth,
+               void(const SSLConfig& used_ssl_config,
+                    SSLCertRequestInfo* cert_info));
+
+  MOCK_METHOD4(OnHttpsProxyTunnelResponse,
+               void(const HttpResponseInfo& response_info,
+                    const SSLConfig& used_ssl_config,
+                    const ProxyInfo& used_proxy_info,
+                    HttpStream* stream));
+
+  MOCK_METHOD0(OnQuicBroken, void());
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(TestHttpStreamRequestDelegate);
+};
+
+class TestHttpStreamFactoryImplJob : public HttpStreamFactoryImpl::Job {
+ public:
+  TestHttpStreamFactoryImplJob(HttpStreamFactoryImpl::Job::Delegate* delegate,
+                               HttpStreamFactoryImpl::JobType job_type,
+                               HttpNetworkSession* session,
+                               const HttpRequestInfo& request_info,
+                               RequestPriority priority,
+                               const SSLConfig& server_ssl_config,
+                               const SSLConfig& proxy_ssl_config,
+                               HostPortPair destination,
+                               GURL origin_url,
+                               NetLog* net_log);
+
+  TestHttpStreamFactoryImplJob(HttpStreamFactoryImpl::Job::Delegate* delegate,
+                               HttpStreamFactoryImpl::JobType job_type,
+                               HttpNetworkSession* session,
+                               const HttpRequestInfo& request_info,
+                               RequestPriority priority,
+                               const SSLConfig& server_ssl_config,
+                               const SSLConfig& proxy_ssl_config,
+                               HostPortPair destination,
+                               GURL origin_url,
+                               AlternativeService alternative_service,
+                               NetLog* net_log);
+
+  ~TestHttpStreamFactoryImplJob() override;
+
+  MOCK_METHOD1(Start, void(HttpStreamRequest::StreamType stream_type));
+
+  MOCK_METHOD1(MarkOtherJobComplete, void(const Job& job));
+
+  MOCK_METHOD0(Orphan, void());
+};
+
+class TestJobFactory : public HttpStreamFactoryImpl::JobController::JobFactory {
+ public:
+  TestJobFactory();
+  ~TestJobFactory() override;
+
+  HttpStreamFactoryImpl::Job* CreateJob(
+      HttpStreamFactoryImpl::Job::Delegate* delegate,
+      HttpStreamFactoryImpl::JobType job_type,
+      HttpNetworkSession* session,
+      const HttpRequestInfo& request_info,
+      RequestPriority priority,
+      const SSLConfig& server_ssl_config,
+      const SSLConfig& proxy_ssl_config,
+      HostPortPair destination,
+      GURL origin_url,
+      NetLog* net_log) override;
+
+  HttpStreamFactoryImpl::Job* CreateJob(
+      HttpStreamFactoryImpl::Job::Delegate* delegate,
+      HttpStreamFactoryImpl::JobType job_type,
+      HttpNetworkSession* session,
+      const HttpRequestInfo& request_info,
+      RequestPriority priority,
+      const SSLConfig& server_ssl_config,
+      const SSLConfig& proxy_ssl_config,
+      HostPortPair destination,
+      GURL origin_url,
+      AlternativeService alternative_service,
+      NetLog* net_log) override;
+
+  TestHttpStreamFactoryImplJob* main_job() const { return main_job_; }
+  TestHttpStreamFactoryImplJob* alternative_job() const {
+    return alternative_job_;
+  }
+
+ private:
+  TestHttpStreamFactoryImplJob* main_job_;
+  TestHttpStreamFactoryImplJob* alternative_job_;
+};
+
+}  // namespace net
+
+#endif  // NET_HTTP_HTTP_STREAM_FACTORY_TEST_UTIL_H_