| OLD | NEW |
|---|
| (Empty) |
| 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 "content/browser/android/child_process_launcher_android.h" | |
| 6 | |
| 7 #include <stddef.h> | |
| 8 #include <stdint.h> | |
| 9 | |
| 10 #include <memory> | |
| 11 #include <utility> | |
| 12 | |
| 13 #include "base/android/context_utils.h" | |
| 14 #include "base/android/jni_android.h" | |
| 15 #include "base/android/jni_array.h" | |
| 16 #include "base/android/unguessable_token_android.h" | |
| 17 #include "base/logging.h" | |
| 18 #include "content/browser/android/scoped_surface_request_manager.h" | |
| 19 #include "content/browser/frame_host/render_frame_host_impl.h" | |
| 20 #include "content/browser/media/android/browser_media_player_manager.h" | |
| 21 #include "content/browser/media/android/media_web_contents_observer_android.h" | |
| 22 #include "content/browser/web_contents/web_contents_impl.h" | |
| 23 #include "content/public/browser/browser_thread.h" | |
| 24 #include "content/public/browser/render_process_host.h" | |
| 25 #include "content/public/common/content_switches.h" | |
| 26 #include "gpu/ipc/common/gpu_surface_tracker.h" | |
| 27 #include "jni/ChildProcessLauncher_jni.h" | |
| 28 #include "media/base/android/media_player_android.h" | |
| 29 #include "ui/gl/android/surface_texture.h" | |
| 30 | |
| 31 using base::android::AttachCurrentThread; | |
| 32 using base::android::JavaParamRef; | |
| 33 using base::android::JavaRef; | |
| 34 using base::android::ToJavaArrayOfStrings; | |
| 35 using base::android::ScopedJavaGlobalRef; | |
| 36 using base::android::ScopedJavaLocalRef; | |
| 37 using content::StartChildProcessCallback; | |
| 38 | |
| 39 namespace content { | |
| 40 | |
| 41 namespace { | |
| 42 | |
| 43 // Pass a java surface object to the MediaPlayerAndroid object | |
| 44 // identified by render process handle, render frame ID and player ID. | |
| 45 static void SetSurfacePeer( | |
| 46 const base::android::JavaRef<jobject>& surface, | |
| 47 base::ProcessHandle render_process_handle, | |
| 48 int render_frame_id, | |
| 49 int player_id) { | |
| 50 int render_process_id = 0; | |
| 51 RenderProcessHost::iterator it = RenderProcessHost::AllHostsIterator(); | |
| 52 while (!it.IsAtEnd()) { | |
| 53 if (it.GetCurrentValue()->GetHandle() == render_process_handle) { | |
| 54 render_process_id = it.GetCurrentValue()->GetID(); | |
| 55 break; | |
| 56 } | |
| 57 it.Advance(); | |
| 58 } | |
| 59 if (!render_process_id) { | |
| 60 DVLOG(1) << "Cannot find render process for render_process_handle " | |
| 61 << render_process_handle; | |
| 62 return; | |
| 63 } | |
| 64 | |
| 65 RenderFrameHostImpl* frame = | |
| 66 RenderFrameHostImpl::FromID(render_process_id, render_frame_id); | |
| 67 if (!frame) { | |
| 68 DVLOG(1) << "Cannot find frame for render_frame_id " << render_frame_id; | |
| 69 return; | |
| 70 } | |
| 71 | |
| 72 BrowserMediaPlayerManager* player_manager = | |
| 73 MediaWebContentsObserverAndroid::FromWebContents( | |
| 74 WebContents::FromRenderFrameHost(frame)) | |
| 75 ->GetMediaPlayerManager(frame); | |
| 76 if (!player_manager) { | |
| 77 DVLOG(1) << "Cannot find the media player manager for frame " << frame; | |
| 78 return; | |
| 79 } | |
| 80 | |
| 81 media::MediaPlayerAndroid* player = player_manager->GetPlayer(player_id); | |
| 82 if (!player) { | |
| 83 DVLOG(1) << "Cannot find media player for player_id " << player_id; | |
| 84 return; | |
| 85 } | |
| 86 | |
| 87 if (player != player_manager->GetFullscreenPlayer()) { | |
| 88 gl::ScopedJavaSurface scoped_surface(surface); | |
| 89 player->SetVideoSurface(std::move(scoped_surface)); | |
| 90 } | |
| 91 } | |
| 92 | |
| 93 } // anonymous namespace | |
| 94 | |
| 95 // Called from ChildProcessLauncher.java when the ChildProcess was | |
| 96 // started. | |
| 97 // |client_context| is the pointer to StartChildProcessCallback which was | |
| 98 // passed in from StartChildProcess. | |
| 99 // |handle| is the processID of the child process as originated in Java, 0 if | |
| 100 // the ChildProcess could not be created. | |
| 101 static void OnChildProcessStarted(JNIEnv*, | |
| 102 const JavaParamRef<jclass>&, | |
| 103 jlong client_context, | |
| 104 jint handle) { | |
| 105 StartChildProcessCallback* callback = | |
| 106 reinterpret_cast<StartChildProcessCallback*>(client_context); | |
| 107 if (handle) | |
| 108 callback->Run(static_cast<base::ProcessHandle>(handle)); | |
| 109 delete callback; | |
| 110 } | |
| 111 | |
| 112 void StartChildProcess( | |
| 113 const base::CommandLine::StringVector& argv, | |
| 114 int child_process_id, | |
| 115 std::unique_ptr<content::FileDescriptorInfo> files_to_register, | |
| 116 const StartChildProcessCallback& callback) { | |
| 117 JNIEnv* env = AttachCurrentThread(); | |
| 118 DCHECK(env); | |
| 119 | |
| 120 // Create the Command line String[] | |
| 121 ScopedJavaLocalRef<jobjectArray> j_argv = ToJavaArrayOfStrings(env, argv); | |
| 122 | |
| 123 size_t file_count = files_to_register->GetMappingSize(); | |
| 124 DCHECK(file_count > 0); | |
| 125 | |
| 126 ScopedJavaLocalRef<jclass> j_file_info_class = base::android::GetClass( | |
| 127 env, "org/chromium/content/common/FileDescriptorInfo"); | |
| 128 ScopedJavaLocalRef<jobjectArray> j_file_infos( | |
| 129 env, env->NewObjectArray(file_count, j_file_info_class.obj(), NULL)); | |
| 130 base::android::CheckException(env); | |
| 131 | |
| 132 for (size_t i = 0; i < file_count; ++i) { | |
| 133 int fd = files_to_register->GetFDAt(i); | |
| 134 PCHECK(0 <= fd); | |
| 135 int id = files_to_register->GetIDAt(i); | |
| 136 bool auto_close = files_to_register->OwnsFD(fd); | |
| 137 const base::MemoryMappedFile::Region& region = | |
| 138 files_to_register->GetRegionAt(i); | |
| 139 int64_t offset = region.offset; | |
| 140 int64_t size = region.size; | |
| 141 ScopedJavaLocalRef<jobject> j_file_info = | |
| 142 Java_ChildProcessLauncher_makeFdInfo(env, id, fd, auto_close, offset, | |
| 143 size); | |
| 144 PCHECK(j_file_info.obj()); | |
| 145 env->SetObjectArrayElement(j_file_infos.obj(), i, j_file_info.obj()); | |
| 146 if (auto_close) { | |
| 147 ignore_result(files_to_register->ReleaseFD(fd).release()); | |
| 148 } | |
| 149 } | |
| 150 | |
| 151 Java_ChildProcessLauncher_start( | |
| 152 env, base::android::GetApplicationContext(), j_argv, child_process_id, | |
| 153 j_file_infos, | |
| 154 reinterpret_cast<intptr_t>(new StartChildProcessCallback(callback))); | |
| 155 } | |
| 156 | |
| 157 void StopChildProcess(base::ProcessHandle handle) { | |
| 158 JNIEnv* env = AttachCurrentThread(); | |
| 159 DCHECK(env); | |
| 160 Java_ChildProcessLauncher_stop(env, static_cast<jint>(handle)); | |
| 161 } | |
| 162 | |
| 163 bool IsChildProcessOomProtected(base::ProcessHandle handle) { | |
| 164 JNIEnv* env = AttachCurrentThread(); | |
| 165 DCHECK(env); | |
| 166 return Java_ChildProcessLauncher_isOomProtected(env, | |
| 167 static_cast<jint>(handle)); | |
| 168 } | |
| 169 | |
| 170 void SetChildProcessInForeground(base::ProcessHandle handle, | |
| 171 bool in_foreground) { | |
| 172 JNIEnv* env = AttachCurrentThread(); | |
| 173 DCHECK(env); | |
| 174 return Java_ChildProcessLauncher_setInForeground(env, | |
| 175 static_cast<jint>(handle), static_cast<jboolean>(in_foreground)); | |
| 176 } | |
| 177 | |
| 178 void EstablishSurfacePeer(JNIEnv* env, | |
| 179 const JavaParamRef<jclass>& clazz, | |
| 180 jint pid, | |
| 181 const JavaParamRef<jobject>& surface, | |
| 182 jint primary_id, | |
| 183 jint secondary_id) { | |
| 184 ScopedJavaGlobalRef<jobject> jsurface; | |
| 185 jsurface.Reset(env, surface); | |
| 186 if (jsurface.is_null()) | |
| 187 return; | |
| 188 | |
| 189 DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::UI)); | |
| 190 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, base::Bind( | |
| 191 &SetSurfacePeer, jsurface, pid, primary_id, secondary_id)); | |
| 192 } | |
| 193 | |
| 194 void CompleteScopedSurfaceRequest(JNIEnv* env, | |
| 195 const JavaParamRef<jclass>& clazz, | |
| 196 const JavaParamRef<jobject>& token, | |
| 197 const JavaParamRef<jobject>& surface) { | |
| 198 base::UnguessableToken requestToken = | |
| 199 base::android::UnguessableTokenAndroid::FromJavaUnguessableToken(env, | |
| 200 token); | |
| 201 if (!requestToken) { | |
| 202 DLOG(ERROR) << "Received invalid surface request token."; | |
| 203 return; | |
| 204 } | |
| 205 | |
| 206 DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::UI)); | |
| 207 | |
| 208 ScopedJavaGlobalRef<jobject> jsurface; | |
| 209 jsurface.Reset(env, surface); | |
| 210 ScopedSurfaceRequestManager::GetInstance()->FulfillScopedSurfaceRequest( | |
| 211 requestToken, gl::ScopedJavaSurface(jsurface)); | |
| 212 } | |
| 213 | |
| 214 jboolean IsSingleProcess(JNIEnv* env, const JavaParamRef<jclass>& clazz) { | |
| 215 return base::CommandLine::ForCurrentProcess()->HasSwitch( | |
| 216 switches::kSingleProcess); | |
| 217 } | |
| 218 | |
| 219 base::android::ScopedJavaLocalRef<jobject> GetViewSurface(JNIEnv* env, | |
| 220 const base::android::JavaParamRef<jclass>& jcaller, | |
| 221 jint surface_id) { | |
| 222 gl::ScopedJavaSurface surface_view = | |
| 223 gpu::GpuSurfaceTracker::GetInstance()->AcquireJavaSurface(surface_id); | |
| 224 return base::android::ScopedJavaLocalRef<jobject>(surface_view.j_surface()); | |
| 225 } | |
| 226 | |
| 227 bool RegisterChildProcessLauncher(JNIEnv* env) { | |
| 228 return RegisterNativesImpl(env); | |
| 229 } | |
| 230 | |
| 231 } // namespace content | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2594203004:
Unifying ChildProcessLauncher across platforms. (Closed)
