1// Copyright (c) 2012 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "net/proxy/network_delegate_error_observer.h"
6
7#include "base/bind.h"
8#include "base/bind_helpers.h"
9#include "base/message_loop/message_loop_proxy.h"
10#include "base/threading/thread.h"
11#include "net/base/net_errors.h"
12#include "net/base/network_delegate.h"
13#include "testing/gtest/include/gtest/gtest.h"
14
15namespace net {
16
17namespace {
18
19class TestNetworkDelegate : public net::NetworkDelegate {
20 public:
21  TestNetworkDelegate() : got_pac_error_(false) {}
22  virtual ~TestNetworkDelegate() {}
23
24  bool got_pac_error() const { return got_pac_error_; }
25
26 private:
27  // net::NetworkDelegate implementation.
28  virtual int OnBeforeURLRequest(URLRequest* request,
29                                 const CompletionCallback& callback,
30                                 GURL* new_url) OVERRIDE {
31    return OK;
32  }
33  virtual int OnBeforeSendHeaders(URLRequest* request,
34                                  const CompletionCallback& callback,
35                                  HttpRequestHeaders* headers) OVERRIDE {
36    return OK;
37  }
38  virtual void OnSendHeaders(URLRequest* request,
39                             const HttpRequestHeaders& headers) OVERRIDE {}
40  virtual int OnHeadersReceived(
41      URLRequest* request,
42      const CompletionCallback& callback,
43      const HttpResponseHeaders* original_response_headers,
44      scoped_refptr<HttpResponseHeaders>* override_response_headers,
45      GURL* allowed_unsafe_redirect_url) OVERRIDE {
46    return net::OK;
47  }
48  virtual void OnBeforeRedirect(URLRequest* request,
49                                const GURL& new_location) OVERRIDE {}
50  virtual void OnResponseStarted(URLRequest* request) OVERRIDE {}
51  virtual void OnRawBytesRead(const URLRequest& request,
52                              int bytes_read) OVERRIDE {}
53  virtual void OnCompleted(URLRequest* request, bool started) OVERRIDE {}
54  virtual void OnURLRequestDestroyed(URLRequest* request) OVERRIDE {}
55
56  virtual void OnPACScriptError(int line_number,
57                                const base::string16& error) OVERRIDE {
58    got_pac_error_ = true;
59  }
60  virtual AuthRequiredResponse OnAuthRequired(
61      URLRequest* request,
62      const AuthChallengeInfo& auth_info,
63      const AuthCallback& callback,
64      AuthCredentials* credentials) OVERRIDE {
65    return AUTH_REQUIRED_RESPONSE_NO_ACTION;
66  }
67  virtual bool OnCanGetCookies(const URLRequest& request,
68                               const CookieList& cookie_list) OVERRIDE {
69    return true;
70  }
71  virtual bool OnCanSetCookie(const URLRequest& request,
72                              const std::string& cookie_line,
73                              CookieOptions* options) OVERRIDE {
74    return true;
75  }
76  virtual bool OnCanAccessFile(const net::URLRequest& request,
77                               const base::FilePath& path) const OVERRIDE {
78    return true;
79  }
80  virtual bool OnCanThrottleRequest(const URLRequest& request) const OVERRIDE {
81    return false;
82  }
83  virtual int OnBeforeSocketStreamConnect(
84      SocketStream* stream,
85      const CompletionCallback& callback) OVERRIDE {
86    return OK;
87  }
88
89  bool got_pac_error_;
90};
91
92}  // namespace
93
94// Check that the OnPACScriptError method can be called from an arbitrary
95// thread.
96TEST(NetworkDelegateErrorObserverTest, CallOnThread) {
97  base::Thread thread("test_thread");
98  thread.Start();
99  TestNetworkDelegate network_delegate;
100  NetworkDelegateErrorObserver observer(
101      &network_delegate, base::MessageLoopProxy::current().get());
102  thread.message_loop()
103      ->PostTask(FROM_HERE,
104                 base::Bind(&NetworkDelegateErrorObserver::OnPACScriptError,
105                            base::Unretained(&observer),
106                            42,
107                            base::string16()));
108  thread.Stop();
109  base::MessageLoop::current()->RunUntilIdle();
110  ASSERT_TRUE(network_delegate.got_pac_error());
111}
112
113// Check that passing a NULL network delegate works.
114TEST(NetworkDelegateErrorObserverTest, NoDelegate) {
115  base::Thread thread("test_thread");
116  thread.Start();
117  NetworkDelegateErrorObserver observer(
118      NULL, base::MessageLoopProxy::current().get());
119  thread.message_loop()
120      ->PostTask(FROM_HERE,
121                 base::Bind(&NetworkDelegateErrorObserver::OnPACScriptError,
122                            base::Unretained(&observer),
123                            42,
124                            base::string16()));
125  thread.Stop();
126  base::MessageLoop::current()->RunUntilIdle();
127  // Shouldn't have crashed until here...
128}
129
130}  // namespace net
131