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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
|
// 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.
#ifndef COMPONENTS_DEVTOOLS_HTTP_HANDLER_DEVTOOLS_HTTP_HANDLER_H_
#define COMPONENTS_DEVTOOLS_HTTP_HANDLER_DEVTOOLS_HTTP_HANDLER_H_
#include <map>
#include <string>
#include "base/files/file_path.h"
#include "base/memory/scoped_ptr.h"
#include "base/memory/weak_ptr.h"
#include "components/devtools_discovery/devtools_target_descriptor.h"
#include "net/http/http_status_code.h"
class GURL;
namespace base {
class DictionaryValue;
class Thread;
class Value;
}
namespace net {
class IPEndPoint;
class HttpServerRequestInfo;
class ServerSocket;
}
namespace devtools_http_handler {
class DevToolsAgentHostClientImpl;
class DevToolsHttpHandlerDelegate;
class ServerWrapper;
// This class is used for managing DevTools remote debugging server.
// Clients can connect to the specified ip:port and start debugging
// this browser.
class DevToolsHttpHandler {
public:
// Factory of net::ServerSocket. This is to separate instantiating dev tools
// and instantiating server sockets.
// All methods including destructor are called on a separate thread
// different from any BrowserThread instance.
class ServerSocketFactory {
public:
virtual ~ServerSocketFactory() {}
// Returns a new instance of ServerSocket or nullptr if an error occurred.
virtual scoped_ptr<net::ServerSocket> CreateForHttpServer();
// Creates a named socket for reversed tethering implementation (used with
// remote debugging, primarily for mobile).
virtual scoped_ptr<net::ServerSocket> CreateForTethering(
std::string* out_name);
};
// Takes ownership over |socket_factory| and |delegate|.
// If |frontend_url| is empty, assumes it's bundled, and uses
// |delegate->GetFrontendResource()|.
// |delegate| is only accessed on UI thread.
// If |active_port_output_directory| is non-empty, it is assumed the
// socket_factory was initialized with an ephemeral port (0). The
// port selected by the OS will be written to a well-known file in
// the output directory.
DevToolsHttpHandler(
scoped_ptr<ServerSocketFactory> server_socket_factory,
const std::string& frontend_url,
DevToolsHttpHandlerDelegate* delegate,
const base::FilePath& active_port_output_directory,
const base::FilePath& debug_frontend_dir,
const std::string& product_name,
const std::string& user_agent);
~DevToolsHttpHandler();
// Returns the URL for the file at |path| in frontend.
GURL GetFrontendURL(const std::string& path);
private:
friend class ServerWrapper;
friend void ServerStartedOnUI(
base::WeakPtr<DevToolsHttpHandler> handler,
base::Thread* thread,
ServerWrapper* server_wrapper,
DevToolsHttpHandler::ServerSocketFactory* socket_factory,
scoped_ptr<net::IPEndPoint> ip_address);
void OnJsonRequest(int connection_id,
const net::HttpServerRequestInfo& info);
void OnThumbnailRequest(int connection_id, const std::string& target_id);
void OnDiscoveryPageRequest(int connection_id);
void OnFrontendResourceRequest(int connection_id, const std::string& path);
void OnWebSocketRequest(int connection_id,
const net::HttpServerRequestInfo& info);
void OnWebSocketMessage(int connection_id, const std::string& data);
void OnClose(int connection_id);
void ServerStarted(base::Thread* thread,
ServerWrapper* server_wrapper,
ServerSocketFactory* socket_factory,
scoped_ptr<net::IPEndPoint> ip_address);
devtools_discovery::DevToolsTargetDescriptor* GetDescriptor(
const std::string& target_id);
void SendJson(int connection_id,
net::HttpStatusCode status_code,
base::Value* value,
const std::string& message);
void Send200(int connection_id,
const std::string& data,
const std::string& mime_type);
void Send404(int connection_id);
void Send500(int connection_id,
const std::string& message);
void AcceptWebSocket(int connection_id,
const net::HttpServerRequestInfo& request);
// Returns the front end url without the host at the beginning.
std::string GetFrontendURLInternal(const std::string target_id,
const std::string& host);
base::DictionaryValue* SerializeDescriptor(
const devtools_discovery::DevToolsTargetDescriptor& descriptor,
const std::string& host);
// The thread used by the devtools handler to run server socket.
base::Thread* thread_;
std::string frontend_url_;
std::string product_name_;
std::string user_agent_;
ServerWrapper* server_wrapper_;
scoped_ptr<net::IPEndPoint> server_ip_address_;
typedef std::map<int, DevToolsAgentHostClientImpl*> ConnectionToClientMap;
ConnectionToClientMap connection_to_client_;
const scoped_ptr<DevToolsHttpHandlerDelegate> delegate_;
ServerSocketFactory* socket_factory_;
using DescriptorMap =
std::map<std::string, devtools_discovery::DevToolsTargetDescriptor*>;
DescriptorMap descriptor_map_;
base::WeakPtrFactory<DevToolsHttpHandler> weak_factory_;
DISALLOW_COPY_AND_ASSIGN(DevToolsHttpHandler);
};
} // namespace devtools_http_handler
#endif // COMPONENTS_DEVTOOLS_HTTP_HANDLER_DEVTOOLS_HTTP_HANDLER_H_
|
