network_delegate_error_observer_unittest.cc revision 7d4cd473f85ac64c3747c96c277f9e506a0d2246 
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) OVERRIDE {
45    return net::OK;
46  }
47  virtual void OnBeforeRedirect(URLRequest* request,
48                                const GURL& new_location) OVERRIDE {}
49  virtual void OnResponseStarted(URLRequest* request) OVERRIDE {}
50  virtual void OnRawBytesRead(const URLRequest& request,
51                              int bytes_read) OVERRIDE {}
52  virtual void OnCompleted(URLRequest* request, bool started) OVERRIDE {}
53  virtual void OnURLRequestDestroyed(URLRequest* request) OVERRIDE {}
54
55  virtual void OnPACScriptError(int line_number,
56                                const base::string16& error) OVERRIDE {
57    got_pac_error_ = true;
58  }
59  virtual AuthRequiredResponse OnAuthRequired(
60      URLRequest* request,
61      const AuthChallengeInfo& auth_info,
62      const AuthCallback& callback,
63      AuthCredentials* credentials) OVERRIDE {
64    return AUTH_REQUIRED_RESPONSE_NO_ACTION;
65  }
66  virtual bool OnCanGetCookies(const URLRequest& request,
67                               const CookieList& cookie_list) OVERRIDE {
68    return true;
69  }
70  virtual bool OnCanSetCookie(const URLRequest& request,
71                              const std::string& cookie_line,
72                              CookieOptions* options) OVERRIDE {
73    return true;
74  }
75  virtual bool OnCanAccessFile(const net::URLRequest& request,
76                               const base::FilePath& path) const OVERRIDE {
77    return true;
78  }
79  virtual bool OnCanThrottleRequest(const URLRequest& request) const OVERRIDE {
80    return false;
81  }
82  virtual int OnBeforeSocketStreamConnect(
83      SocketStream* stream,
84      const CompletionCallback& callback) OVERRIDE {
85    return OK;
86  }
87  virtual void OnRequestWaitStateChange(const net::URLRequest& request,
88                                        RequestWaitState state) OVERRIDE {
89  }
90
91  bool got_pac_error_;
92};
93
94}  // namespace
95
96// Check that the OnPACScriptError method can be called from an arbitrary
97// thread.
98TEST(NetworkDelegateErrorObserverTest, CallOnThread) {
99  base::Thread thread("test_thread");
100  thread.Start();
101  TestNetworkDelegate network_delegate;
102  NetworkDelegateErrorObserver observer(
103      &network_delegate, base::MessageLoopProxy::current().get());
104  thread.message_loop()
105      ->PostTask(FROM_HERE,
106                 base::Bind(&NetworkDelegateErrorObserver::OnPACScriptError,
107                            base::Unretained(&observer),
108                            42,
109                            base::string16()));
110  thread.Stop();
111  base::MessageLoop::current()->RunUntilIdle();
112  ASSERT_TRUE(network_delegate.got_pac_error());
113}
114
115// Check that passing a NULL network delegate works.
116TEST(NetworkDelegateErrorObserverTest, NoDelegate) {
117  base::Thread thread("test_thread");
118  thread.Start();
119  NetworkDelegateErrorObserver observer(
120      NULL, base::MessageLoopProxy::current().get());
121  thread.message_loop()
122      ->PostTask(FROM_HERE,
123                 base::Bind(&NetworkDelegateErrorObserver::OnPACScriptError,
124                            base::Unretained(&observer),
125                            42,
126                            base::string16()));
127  thread.Stop();
128  base::MessageLoop::current()->RunUntilIdle();
129  // Shouldn't have crashed until here...
130}
131
132}  // namespace net
133