xref: /aosp_15_r20/external/cronet/net/test/embedded_test_server/android/embedded_test_server_android.cc (revision 6777b5387eb2ff775bb5750e3f5d96f37fb7352b)
1 // Copyright 2015 The Chromium Authors
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/test/embedded_test_server/android/embedded_test_server_android.h"
6 
7 #include "base/android/jni_array.h"
8 #include "base/android/jni_string.h"
9 #include "base/android/scoped_java_ref.h"
10 #include "base/files/file_path.h"
11 #include "base/functional/bind.h"
12 #include "base/test/test_support_android.h"
13 #include "net/android/net_test_support_provider_jni/EmbeddedTestServerImpl_jni.h"
14 #include "net/base/tracing.h"
15 
16 using base::android::JavaParamRef;
17 using base::android::JavaRef;
18 using base::android::ScopedJavaLocalRef;
19 
20 namespace net::test_server {
21 
ConnectionListener(EmbeddedTestServerAndroid * test_server_android)22 EmbeddedTestServerAndroid::ConnectionListener::ConnectionListener(
23     EmbeddedTestServerAndroid* test_server_android)
24     : test_server_android_(test_server_android) {}
25 
26 EmbeddedTestServerAndroid::ConnectionListener::~ConnectionListener() = default;
27 
28 std::unique_ptr<StreamSocket>
AcceptedSocket(std::unique_ptr<StreamSocket> socket)29 EmbeddedTestServerAndroid::ConnectionListener::AcceptedSocket(
30     std::unique_ptr<StreamSocket> socket) {
31   test_server_android_->AcceptedSocket(static_cast<const void*>(socket.get()));
32   return socket;
33 }
34 
ReadFromSocket(const StreamSocket & socket,int rv)35 void EmbeddedTestServerAndroid::ConnectionListener::ReadFromSocket(
36     const StreamSocket& socket,
37     int rv) {
38   test_server_android_->ReadFromSocket(static_cast<const void*>(&socket));
39 }
40 
41 void EmbeddedTestServerAndroid::ConnectionListener::
OnResponseCompletedSuccessfully(std::unique_ptr<StreamSocket> socket)42     OnResponseCompletedSuccessfully(std::unique_ptr<StreamSocket> socket) {}
43 
EmbeddedTestServerAndroid(JNIEnv * env,const JavaRef<jobject> & jobj,jboolean jhttps)44 EmbeddedTestServerAndroid::EmbeddedTestServerAndroid(
45     JNIEnv* env,
46     const JavaRef<jobject>& jobj,
47     jboolean jhttps)
48     : weak_java_server_(env, jobj),
49       test_server_(jhttps ? EmbeddedTestServer::TYPE_HTTPS
50                           : EmbeddedTestServer::TYPE_HTTP),
51       connection_listener_(this) {
52   test_server_.SetConnectionListener(&connection_listener_);
53   Java_EmbeddedTestServerImpl_setNativePtr(env, jobj,
54                                            reinterpret_cast<intptr_t>(this));
55 }
56 
~EmbeddedTestServerAndroid()57 EmbeddedTestServerAndroid::~EmbeddedTestServerAndroid() {
58   JNIEnv* env = base::android::AttachCurrentThread();
59   Java_EmbeddedTestServerImpl_clearNativePtr(env, weak_java_server_.get(env));
60 }
61 
Start(JNIEnv * env,jint port)62 jboolean EmbeddedTestServerAndroid::Start(JNIEnv* env, jint port) {
63   return test_server_.Start(static_cast<int>(port));
64 }
65 
GetRootCertPemPath(JNIEnv * env) const66 ScopedJavaLocalRef<jstring> EmbeddedTestServerAndroid::GetRootCertPemPath(
67     JNIEnv* env) const {
68   return base::android::ConvertUTF8ToJavaString(
69       env, test_server_.GetRootCertPemPath().value());
70 }
71 
ShutdownAndWaitUntilComplete(JNIEnv * env)72 jboolean EmbeddedTestServerAndroid::ShutdownAndWaitUntilComplete(JNIEnv* env) {
73   return test_server_.ShutdownAndWaitUntilComplete();
74 }
75 
GetURL(JNIEnv * env,const JavaParamRef<jstring> & jrelative_url) const76 ScopedJavaLocalRef<jstring> EmbeddedTestServerAndroid::GetURL(
77     JNIEnv* env,
78     const JavaParamRef<jstring>& jrelative_url) const {
79   const GURL gurl(test_server_.GetURL(
80       base::android::ConvertJavaStringToUTF8(env, jrelative_url)));
81   return base::android::ConvertUTF8ToJavaString(env, gurl.spec());
82 }
83 
GetURLWithHostName(JNIEnv * env,const JavaParamRef<jstring> & jhostname,const JavaParamRef<jstring> & jrelative_url) const84 ScopedJavaLocalRef<jstring> EmbeddedTestServerAndroid::GetURLWithHostName(
85     JNIEnv* env,
86     const JavaParamRef<jstring>& jhostname,
87     const JavaParamRef<jstring>& jrelative_url) const {
88   const GURL gurl(test_server_.GetURL(
89       base::android::ConvertJavaStringToUTF8(env, jhostname),
90       base::android::ConvertJavaStringToUTF8(env, jrelative_url)));
91   return base::android::ConvertUTF8ToJavaString(env, gurl.spec());
92 }
93 
AddDefaultHandlers(JNIEnv * env,const JavaParamRef<jstring> & jdirectory_path)94 void EmbeddedTestServerAndroid::AddDefaultHandlers(
95     JNIEnv* env,
96     const JavaParamRef<jstring>& jdirectory_path) {
97   const base::FilePath directory(
98       base::android::ConvertJavaStringToUTF8(env, jdirectory_path));
99   test_server_.AddDefaultHandlers(directory);
100 }
101 
SetSSLConfig(JNIEnv * jenv,jint jserver_certificate)102 void EmbeddedTestServerAndroid::SetSSLConfig(JNIEnv* jenv,
103                                              jint jserver_certificate) {
104   test_server_.SetSSLConfig(
105       static_cast<EmbeddedTestServer::ServerCertificate>(jserver_certificate));
106 }
107 
108 typedef std::unique_ptr<HttpResponse> (*HandleRequestPtr)(
109     const HttpRequest& request);
110 
RegisterRequestHandler(JNIEnv * env,jlong handler)111 void EmbeddedTestServerAndroid::RegisterRequestHandler(JNIEnv* env,
112                                                        jlong handler) {
113   HandleRequestPtr handler_ptr = reinterpret_cast<HandleRequestPtr>(handler);
114   test_server_.RegisterRequestHandler(base::BindRepeating(handler_ptr));
115 }
116 
ServeFilesFromDirectory(JNIEnv * env,const JavaParamRef<jstring> & jdirectory_path)117 void EmbeddedTestServerAndroid::ServeFilesFromDirectory(
118     JNIEnv* env,
119     const JavaParamRef<jstring>& jdirectory_path) {
120   const base::FilePath directory(
121       base::android::ConvertJavaStringToUTF8(env, jdirectory_path));
122   test_server_.ServeFilesFromDirectory(directory);
123 }
124 
AcceptedSocket(const void * socket_id)125 void EmbeddedTestServerAndroid::AcceptedSocket(const void* socket_id) {
126   JNIEnv* env = base::android::AttachCurrentThread();
127   Java_EmbeddedTestServerImpl_acceptedSocket(
128       env, weak_java_server_.get(env), reinterpret_cast<intptr_t>(socket_id));
129 }
130 
ReadFromSocket(const void * socket_id)131 void EmbeddedTestServerAndroid::ReadFromSocket(const void* socket_id) {
132   JNIEnv* env = base::android::AttachCurrentThread();
133   Java_EmbeddedTestServerImpl_readFromSocket(
134       env, weak_java_server_.get(env), reinterpret_cast<intptr_t>(socket_id));
135 }
136 
Destroy(JNIEnv * env)137 void EmbeddedTestServerAndroid::Destroy(JNIEnv* env) {
138   delete this;
139 }
140 
JNI_EmbeddedTestServerImpl_Init(JNIEnv * env,const JavaParamRef<jobject> & jobj,const JavaParamRef<jstring> & jtest_data_dir,jboolean jhttps)141 static void JNI_EmbeddedTestServerImpl_Init(
142     JNIEnv* env,
143     const JavaParamRef<jobject>& jobj,
144     const JavaParamRef<jstring>& jtest_data_dir,
145     jboolean jhttps) {
146   TRACE_EVENT0("native", "EmbeddedTestServerAndroid::Init");
147   base::FilePath test_data_dir(
148       base::android::ConvertJavaStringToUTF8(env, jtest_data_dir));
149   base::InitAndroidTestPaths(test_data_dir);
150 
151   // Bare new does not leak here because the instance deletes itself when it
152   // receives a Destroy() call its Java counterpart. The Java counterpart owns
153   // the instance created here.
154   new EmbeddedTestServerAndroid(env, jobj, jhttps);
155 }
156 
157 }  // namespace net::test_server
158