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
|
// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CHROME_BROWSER_EXTENSIONS_API_MESSAGING_NATIVE_MESSAGE_PROCESS_HOST_H_
#define CHROME_BROWSER_EXTENSIONS_API_MESSAGING_NATIVE_MESSAGE_PROCESS_HOST_H_
#include <memory>
#include <string>
#include "base/containers/queue.h"
#include "base/files/platform_file.h"
#include "base/memory/raw_ptr.h"
#include "base/memory/weak_ptr.h"
#include "base/process/process.h"
#include "base/task/single_thread_task_runner.h"
#include "build/build_config.h"
#include "chrome/browser/extensions/api/messaging/native_process_launcher.h"
#include "extensions/browser/api/messaging/native_message_host.h"
#if BUILDFLAG(IS_POSIX)
#include "base/files/file_descriptor_watcher_posix.h"
#endif
namespace net {
class DrainableIOBuffer;
class FileStream;
class IOBuffer;
class IOBufferWithSize;
} // namespace net
namespace extensions {
// Manages the native side of a connection between an extension and a native
// process.
//
// This class must only be created, called, and deleted on the IO thread.
// Public methods typically accept callbacks which will be invoked on the UI
// thread.
class NativeMessageProcessHost : public NativeMessageHost {
public:
NativeMessageProcessHost(const NativeMessageProcessHost&) = delete;
NativeMessageProcessHost& operator=(const NativeMessageProcessHost&) = delete;
~NativeMessageProcessHost() override;
// Create using specified `launcher`. Used in tests.
static std::unique_ptr<NativeMessageHost> CreateWithLauncher(
const std::string& source_extension_id,
const std::string& native_host_name,
std::unique_ptr<NativeProcessLauncher> launcher);
// extensions::NativeMessageHost implementation.
void OnMessage(const std::string& message) override;
void Start(Client* client) override;
scoped_refptr<base::SingleThreadTaskRunner> task_runner() const override;
private:
NativeMessageProcessHost(const std::string& source_extension_id,
const std::string& native_host_name,
std::unique_ptr<NativeProcessLauncher> launcher);
// Starts the host process.
void LaunchHostProcess();
// Callback for NativeProcessLauncher::Launch().
void OnHostProcessLaunched(NativeProcessLauncher::LaunchResult result,
base::Process process,
base::PlatformFile read_file,
std::unique_ptr<net::FileStream> read_stream,
std::unique_ptr<net::FileStream> write_stream);
// Helper methods to read incoming messages.
void WaitRead();
void DoRead();
void OnRead(int result);
void HandleReadResult(int result);
void ProcessIncomingData(const char* data, int data_size);
// Helper methods to write outgoing messages.
void DoWrite();
void HandleWriteResult(int result);
void OnWritten(int result);
// Closes the connection and reports the `error_message` to the client.
void Close(const std::string& error_message);
// The Client messages will be posted to. Should only be accessed from the
// UI thread.
raw_ptr<Client> client_;
// ID of the calling extension.
std::string source_extension_id_;
// Name of the native messaging host.
std::string native_host_name_;
// Launcher used to launch the native process.
std::unique_ptr<NativeProcessLauncher> launcher_;
// Set to true after the native messaging connection has been stopped, e.g.
// due to an error.
bool closed_;
base::Process process_;
// Input stream reader.
std::unique_ptr<net::FileStream> read_stream_;
#if BUILDFLAG(IS_POSIX)
base::PlatformFile read_file_;
std::unique_ptr<base::FileDescriptorWatcher::Controller> read_controller_;
#endif // !BUILDFLAG(IS_POSIX)
// Write stream.
std::unique_ptr<net::FileStream> write_stream_;
// Read buffer passed to FileStream::Read().
scoped_refptr<net::IOBuffer> read_buffer_;
// Set to true when a read is pending.
bool read_pending_;
// Buffer for incomplete incoming messages.
std::string incoming_data_;
// Queue for outgoing messages.
base::queue<scoped_refptr<net::IOBufferWithSize>> write_queue_;
// The message that's currently being sent.
scoped_refptr<net::DrainableIOBuffer> current_write_buffer_;
// Set to true when a write is pending.
bool write_pending_;
scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
base::WeakPtrFactory<NativeMessageProcessHost> weak_factory_{this};
};
} // namespace extensions
#endif // CHROME_BROWSER_EXTENSIONS_API_MESSAGING_NATIVE_MESSAGE_PROCESS_HOST_H_
|
