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 "testing/gmock/include/gmock/gmock.h"

namespace net {

class HttpStreamFactoryImplPeer {
 public:
  static void AddJobController(
      HttpStreamFactoryImpl* factory,
      HttpStreamFactoryImpl::JobController* job_controller) {
    factory->job_controller_set_.insert(base::WrapUnique(job_controller));
  }

  static bool IsJobControllerDeleted(HttpStreamFactoryImpl* factory) {
    return factory->job_controller_set_.empty();
  }

  static HttpStreamFactoryImpl::JobFactory* GetDefaultJobFactory(
      HttpStreamFactoryImpl* factory) {
    return factory->job_factory_.get();
  }
};

// This delegate does nothing when called.
class MockHttpStreamRequestDelegate : public HttpStreamRequest::Delegate {
 public:
  MockHttpStreamRequestDelegate();

  ~MockHttpStreamRequestDelegate() override;

  MOCK_METHOD3(OnStreamReady,
               void(const SSLConfig& used_ssl_config,
                    const ProxyInfo& used_proxy_info,
                    HttpStream* stream));

  MOCK_METHOD3(OnBidirectionalStreamImplReady,
               void(const SSLConfig& used_ssl_config,
                    const ProxyInfo& used_proxy_info,
                    BidirectionalStreamImpl* stream));

  MOCK_METHOD3(OnWebSocketHandshakeStreamReady,
               void(const SSLConfig& used_ssl_config,
                    const ProxyInfo& used_proxy_info,
                    WebSocketHandshakeStreamBase* stream));

  MOCK_METHOD2(OnStreamFailed,
               void(int status, const SSLConfig& used_ssl_config));

  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(MockHttpStreamRequestDelegate);
};

class MockHttpStreamFactoryImplJob : public HttpStreamFactoryImpl::Job {
 public:
  MockHttpStreamFactoryImplJob(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);

  MockHttpStreamFactoryImplJob(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);

  ~MockHttpStreamFactoryImplJob() override;

  MOCK_METHOD1(Start, void(HttpStreamRequest::StreamType stream_type));

  MOCK_METHOD1(MarkOtherJobComplete, void(const Job& job));

  MOCK_METHOD0(Orphan, void());
};

// JobFactory for creating MockHttpStreamFactoryImplJobs.
class TestJobFactory : public HttpStreamFactoryImpl::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;

  MockHttpStreamFactoryImplJob* main_job() const { return main_job_; }
  MockHttpStreamFactoryImplJob* alternative_job() const {
    return alternative_job_;
  }

 private:
  MockHttpStreamFactoryImplJob* main_job_;
  MockHttpStreamFactoryImplJob* alternative_job_;
};

}  // namespace net

#endif  // NET_HTTP_HTTP_STREAM_FACTORY_TEST_UTIL_H_