1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
|
// Copyright (c) 2012 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.
#include "base/message_loop.h"
#include "base/run_loop.h"
#include "content/browser/browser_thread_impl.h"
#include "content/public/browser/devtools_http_handler.h"
#include "content/public/browser/devtools_http_handler_delegate.h"
#include "net/socket/stream_listen_socket.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace content {
namespace {
using net::StreamListenSocket;
class DummyListenSocket : public StreamListenSocket,
public StreamListenSocket::Delegate {
public:
DummyListenSocket()
: ALLOW_THIS_IN_INITIALIZER_LIST(StreamListenSocket(0, this)) {}
// StreamListenSocket::Delegate "implementation"
virtual void DidAccept(StreamListenSocket* server,
StreamListenSocket* connection) OVERRIDE {}
virtual void DidRead(StreamListenSocket* connection,
const char* data,
int len) OVERRIDE {}
virtual void DidClose(StreamListenSocket* sock) OVERRIDE {}
protected:
virtual ~DummyListenSocket() {}
virtual void Accept() OVERRIDE {}
};
class DummyListenSocketFactory : public net::StreamListenSocketFactory {
public:
DummyListenSocketFactory(
base::Closure quit_closure_1, base::Closure quit_closure_2)
: quit_closure_1_(quit_closure_1), quit_closure_2_(quit_closure_2) {}
virtual ~DummyListenSocketFactory() {
BrowserThread::PostTask(
BrowserThread::UI, FROM_HERE, quit_closure_2_);
}
virtual scoped_refptr<StreamListenSocket> CreateAndListen(
StreamListenSocket::Delegate* delegate) const OVERRIDE {
BrowserThread::PostTask(
BrowserThread::UI, FROM_HERE, quit_closure_1_);
return new DummyListenSocket();
}
private:
base::Closure quit_closure_1_;
base::Closure quit_closure_2_;
};
class DummyDelegate : public DevToolsHttpHandlerDelegate {
public:
virtual std::string GetDiscoveryPageHTML() OVERRIDE { return std::string(); }
virtual bool BundlesFrontendResources() OVERRIDE { return true; }
virtual base::FilePath GetDebugFrontendDir() OVERRIDE {
return base::FilePath();
}
virtual std::string GetPageThumbnailData(const GURL& url) OVERRIDE {
return std::string();
}
virtual RenderViewHost* CreateNewTarget() OVERRIDE { return NULL; }
virtual TargetType GetTargetType(RenderViewHost*) OVERRIDE {
return kTargetTypeTab;
}
virtual std::string GetViewDescription(content::RenderViewHost*) OVERRIDE {
return std::string();
}
};
}
class DevToolsHttpHandlerTest : public testing::Test {
public:
DevToolsHttpHandlerTest()
: ui_thread_(BrowserThread::UI, &message_loop_) {
}
protected:
virtual void SetUp() {
file_thread_.reset(new BrowserThreadImpl(BrowserThread::FILE));
file_thread_->Start();
}
virtual void TearDown() {
file_thread_->Stop();
}
private:
MessageLoopForIO message_loop_;
BrowserThreadImpl ui_thread_;
scoped_ptr<BrowserThreadImpl> file_thread_;
};
TEST_F(DevToolsHttpHandlerTest, TestStartStop) {
base::RunLoop run_loop, run_loop_2;
content::DevToolsHttpHandler* devtools_http_handler_ =
content::DevToolsHttpHandler::Start(
new DummyListenSocketFactory(run_loop.QuitClosure(),
run_loop_2.QuitClosure()),
std::string(),
new DummyDelegate());
// Our dummy socket factory will post a quit message once the server will
// become ready.
run_loop.Run();
devtools_http_handler_->Stop();
// Make sure the handler actually stops.
run_loop_2.Run();
}
} // namespace content
|
