Refactoring out the chromoting jni runtime class in favor of chromoting client runtime.

remoting/client/jni/jni_gl_display_handler.cc

 // Copyright 2016 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 "remoting/client/jni/jni_gl_display_handler.h"
 
 #include <android/native_window_jni.h>
 #include <array>
 
 #include "base/android/jni_android.h"
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "jni/GlDisplay_jni.h"
+#include "remoting/client/chromoting_client_runtime.h"
 #include "remoting/client/cursor_shape_stub_proxy.h"
 #include "remoting/client/display/gl_canvas.h"
 #include "remoting/client/dual_buffer_frame_consumer.h"
-#include "remoting/client/jni/chromoting_jni_runtime.h"
 #include "remoting/client/jni/egl_thread_context.h"
 #include "remoting/client/software_video_renderer.h"
 #include "remoting/protocol/frame_consumer.h"
 
 namespace remoting {
 
 // The core that lives on the display thread. Must not be created on the display
 // thread.
 class JniGlDisplayHandler::Core : public protocol::CursorShapeStub,
                                   public GlRendererDelegate {
  public:
-  Core(ChromotingJniRuntime* runtime, base::WeakPtr<JniGlDisplayHandler> shell);
+  Core(base::WeakPtr<JniGlDisplayHandler> shell);
   ~Core() override;
 
   // GlRendererDelegate interface.
   bool CanRenderFrame() override;
   void OnFrameRendered() override;
   void OnSizeChanged(int width, int height) override;
 
   // CursorShapeStub interface.
   void SetCursorShape(const protocol::CursorShapeInfo& cursor_shape) override;
 
@@ skipping 12 matching lines @@
   void MoveCursor(float x, float y);
   void SetCursorVisibility(bool visible);
   void StartInputFeedback(float x, float y, float diameter);
 
   base::WeakPtr<Core> GetWeakPtr();
 
  private:
   // Initializes the core on the display thread.
   void Initialize();
 
-  ChromotingJniRuntime* runtime_;
+  ChromotingClientRuntime* runtime_;
   base::WeakPtr<JniGlDisplayHandler> shell_;
 
   // Will be std::move'd when GrabFrameConsumer() is called.
   std::unique_ptr<DualBufferFrameConsumer> owned_frame_consumer_;
 
   base::WeakPtr<DualBufferFrameConsumer> frame_consumer_;
 
   ANativeWindow* window_ = nullptr;
   std::unique_ptr<EglThreadContext> egl_context_;
   std::unique_ptr<GlRenderer> renderer_;
 
   // Used on display thread.
   base::WeakPtr<Core> weak_ptr_;
   base::WeakPtrFactory<Core> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Core);
 };
 
-JniGlDisplayHandler::Core::Core(ChromotingJniRuntime* runtime,
-                                base::WeakPtr<JniGlDisplayHandler> shell)
-    : runtime_(runtime), shell_(shell), weak_factory_(this) {
+JniGlDisplayHandler::Core::Core(base::WeakPtr<JniGlDisplayHandler> shell)
+    : shell_(shell), weak_factory_(this) {
+  runtime_ = ChromotingClientRuntime::GetInstance();
   DCHECK(!runtime_->display_task_runner()->BelongsToCurrentThread());
   runtime_->display_task_runner()->PostTask(
       FROM_HERE, base::Bind(&JniGlDisplayHandler::Core::Initialize,
                             base::Unretained(this)));
 
   weak_ptr_ = weak_factory_.GetWeakPtr();
 
   // Do not bind GlRenderer::OnFrameReceived. |renderer_| is not ready yet.
   owned_frame_consumer_.reset(new DualBufferFrameConsumer(
       base::Bind(&JniGlDisplayHandler::Core::OnFrameReceived, weak_ptr_),
@@ skipping 107 matching lines @@
 void JniGlDisplayHandler::Core::Initialize() {
   DCHECK(runtime_->display_task_runner()->BelongsToCurrentThread());
 
   renderer_ = GlRenderer::CreateGlRendererWithDesktop();
   renderer_->SetDelegate(weak_ptr_);
 }
 
 // Shell implementations.
 
 JniGlDisplayHandler::JniGlDisplayHandler(
-    ChromotingJniRuntime* runtime,
     const base::android::JavaRef<jobject>& java_client)
-    : runtime_(runtime),
-      ui_task_poster_(runtime->display_task_runner()),
+    : runtime_(ChromotingClientRuntime::GetInstance()),
+      ui_task_poster_(runtime_->display_task_runner()),
       weak_factory_(this) {
-  core_.reset(new Core(runtime_, weak_factory_.GetWeakPtr()));
+  core_.reset(new Core(weak_factory_.GetWeakPtr()));
   JNIEnv* env = base::android::AttachCurrentThread();
   java_display_.Reset(Java_GlDisplay_createJavaDisplayObject(
       env, reinterpret_cast<intptr_t>(this)));
   Java_GlDisplay_initializeClient(env, java_display_, java_client);
 }
 
 JniGlDisplayHandler::~JniGlDisplayHandler() {
   DCHECK(runtime_->ui_task_runner()->BelongsToCurrentThread());
   Java_GlDisplay_invalidate(base::android::AttachCurrentThread(),
                             java_display_);
@@ skipping 94 matching lines @@
                                 java_display_);
 }
 
 void JniGlDisplayHandler::OnCanvasSizeChanged(int width, int height) {
   DCHECK(runtime_->ui_task_runner()->BelongsToCurrentThread());
   Java_GlDisplay_changeCanvasSize(base::android::AttachCurrentThread(),
                                   java_display_, width, height);
 }
 
 }  // namespace remoting