Simplify FrameConsumer interface. Remove FrameProducer interface.

remoting/client/jni/chromoting_jni_instance.cc

 // Copyright 2013 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/chromoting_jni_instance.h"
 
 #include <android/log.h>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "jingle/glue/thread_wrapper.h"
 #include "net/socket/client_socket_factory.h"
 #include "remoting/base/service_urls.h"
 #include "remoting/client/audio_player.h"
 #include "remoting/client/client_status_logger.h"
 #include "remoting/client/jni/android_keymap.h"
 #include "remoting/client/jni/chromoting_jni_runtime.h"
+#include "remoting/client/jni/jni_frame_consumer.h"
 #include "remoting/client/software_video_renderer.h"
 #include "remoting/client/token_fetcher_proxy.h"
 #include "remoting/protocol/chromium_port_allocator.h"
 #include "remoting/protocol/chromium_socket_factory.h"
 #include "remoting/protocol/host_stub.h"
 #include "remoting/protocol/libjingle_transport_factory.h"
 #include "remoting/protocol/negotiating_client_authenticator.h"
 #include "remoting/protocol/network_settings.h"
 #include "remoting/signaling/server_log_entry.h"
 
@@ skipping 50 matching lines @@
   auth_methods.push_back(protocol::AuthenticationMethod::Spake2(
       protocol::AuthenticationMethod::NONE));
   auth_methods.push_back(protocol::AuthenticationMethod::ThirdParty());
 
   authenticator_.reset(new protocol::NegotiatingClientAuthenticator(
       pairing_id, pairing_secret, host_id_,
       base::Bind(&ChromotingJniInstance::FetchSecret, this),
       token_fetcher.Pass(), auth_methods));
 
   // Post a task to start connection
-  jni_runtime_->display_task_runner()->PostTask(
+  jni_runtime_->network_task_runner()->PostTask(
       FROM_HERE,
-      base::Bind(&ChromotingJniInstance::ConnectToHostOnDisplayThread,
-                 this));
+      base::Bind(&ChromotingJniInstance::ConnectToHostOnNetworkThread, this));
 }
 
 ChromotingJniInstance::~ChromotingJniInstance() {
   // This object is ref-counted, so this dtor can execute on any thread.
   // Ensure that all these objects have been freed already, so they are not
   // destroyed on some random thread.
   DCHECK(!view_);
   DCHECK(!client_context_);
   DCHECK(!video_renderer_);
   DCHECK(!authenticator_);
   DCHECK(!client_);
   DCHECK(!signaling_);
   DCHECK(!client_status_logger_);
 }
 
 void ChromotingJniInstance::Disconnect() {
-  if (!jni_runtime_->display_task_runner()->BelongsToCurrentThread()) {
-    jni_runtime_->display_task_runner()->PostTask(
+  if (!jni_runtime_->network_task_runner()->BelongsToCurrentThread()) {
+    jni_runtime_->network_task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&ChromotingJniInstance::Disconnect, this));
     return;
   }
 
-  // This must be destroyed on the display thread before the producer is gone.
+  host_id_.clear();
+
+  stats_logging_enabled_ = false;
+
+  // |client_| must be torn down before |signaling_|.
+  client_.reset();
+  client_status_logger_.reset();
+  video_renderer_.reset();
   view_.reset();
-
-  // The weak pointers must be invalidated on the same thread they were used.
-  view_weak_factory_->InvalidateWeakPtrs();
-
-  jni_runtime_->network_task_runner()->PostTask(
-      FROM_HERE,
-      base::Bind(&ChromotingJniInstance::DisconnectFromHostOnNetworkThread,
-                 this));
+  authenticator_.reset();
+  signaling_.reset();
+  client_context_.reset();
 }
 
 void ChromotingJniInstance::FetchThirdPartyToken(
     const GURL& token_url,
     const std::string& client_id,
     const std::string& scope,
     base::WeakPtr<TokenFetcherProxy> token_fetcher_proxy) {
   DCHECK(jni_runtime_->network_task_runner()->BelongsToCurrentThread());
   DCHECK(!token_fetcher_proxy_.get());
 
@@ skipping 239 matching lines @@
   if (!jni_runtime_->display_task_runner()->BelongsToCurrentThread()) {
     jni_runtime_->display_task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&ChromotingJniInstance::SetCursorShape, this, shape));
     return;
   }
 
   jni_runtime_->UpdateCursorShape(shape);
 }
 
-void ChromotingJniInstance::ConnectToHostOnDisplayThread() {
-  DCHECK(jni_runtime_->display_task_runner()->BelongsToCurrentThread());
-
-  view_.reset(new JniFrameConsumer(jni_runtime_, this));
-  view_weak_factory_.reset(new base::WeakPtrFactory<JniFrameConsumer>(
-      view_.get()));
-  scoped_ptr<FrameConsumerProxy> frame_consumer =
-      make_scoped_ptr(new FrameConsumerProxy(view_weak_factory_->GetWeakPtr()));
-
-  jni_runtime_->network_task_runner()->PostTask(
-      FROM_HERE,
-      base::Bind(&ChromotingJniInstance::ConnectToHostOnNetworkThread, this,
-                 base::Passed(&frame_consumer)));
-}
-
-void ChromotingJniInstance::ConnectToHostOnNetworkThread(
-    scoped_ptr<FrameConsumerProxy> frame_consumer) {
+void ChromotingJniInstance::ConnectToHostOnNetworkThread() {
   DCHECK(jni_runtime_->network_task_runner()->BelongsToCurrentThread());
-  DCHECK(frame_consumer);
 
   jingle_glue::JingleThreadWrapper::EnsureForCurrentMessageLoop();
 
   client_context_.reset(new ClientContext(jni_runtime_->network_task_runner()));
   client_context_->Start();
 
-  SoftwareVideoRenderer* renderer = new SoftwareVideoRenderer(
-      client_context_->main_task_runner(),
-      client_context_->decode_task_runner(), frame_consumer.Pass());
-  view_->set_frame_producer(renderer);
-  video_renderer_.reset(renderer);
+  view_.reset(new JniFrameConsumer(jni_runtime_));
+  video_renderer_.reset(new SoftwareVideoRenderer(
+      client_context_->decode_task_runner(), view_.get()));
 
   client_.reset(new ChromotingClient(
       client_context_.get(), this, video_renderer_.get(), nullptr));
 
   signaling_.reset(new XmppSignalStrategy(
       net::ClientSocketFactory::GetDefaultFactory(),
       jni_runtime_->url_requester(), xmpp_config_));
 
   client_status_logger_.reset(
       new ClientStatusLogger(ServerLogEntry::ME2ME,
@@ skipping 10 matching lines @@
 
   scoped_ptr<protocol::TransportFactory> transport_factory(
       new protocol::LibjingleTransportFactory(
           signaling_.get(), port_allocator.Pass(), network_settings,
           protocol::TransportRole::CLIENT));
 
   client_->Start(signaling_.get(), authenticator_.Pass(),
                  transport_factory.Pass(), host_jid_, capabilities_);
 }
 
-void ChromotingJniInstance::DisconnectFromHostOnNetworkThread() {
-  DCHECK(jni_runtime_->network_task_runner()->BelongsToCurrentThread());
-
-  host_id_.clear();
-
-  stats_logging_enabled_ = false;
-
-  // |client_| must be torn down before |signaling_|.
-  client_.reset();
-  client_status_logger_.reset();
-  video_renderer_.reset();
-  authenticator_.reset();
-  signaling_.reset();
-  client_context_.reset();
-}
-
 void ChromotingJniInstance::FetchSecret(
     bool pairable,
     const protocol::SecretFetchedCallback& callback) {
   if (!jni_runtime_->ui_task_runner()->BelongsToCurrentThread()) {
     jni_runtime_->ui_task_runner()->PostTask(
         FROM_HERE, base::Bind(&ChromotingJniInstance::FetchSecret,
                               this, pairable, callback));
     return;
   }
 
@@ skipping 17 matching lines @@
 
 void ChromotingJniInstance::SendKeyEventInternal(int usb_key_code,
                                                  bool key_down) {
   if (!jni_runtime_->network_task_runner()->BelongsToCurrentThread()) {
     jni_runtime_->network_task_runner()->PostTask(
         FROM_HERE, base::Bind(&ChromotingJniInstance::SendKeyEventInternal,
                               this, usb_key_code, key_down));
     return;
   }
 
-
   protocol::KeyEvent event;
   event.set_usb_keycode(usb_key_code);
   event.set_pressed(key_down);
   client_->input_stub()->InjectKeyEvent(event);
 }
 
 void ChromotingJniInstance::EnableStatsLogging(bool enabled) {
   DCHECK(jni_runtime_->network_task_runner()->BelongsToCurrentThread());
 
   if (enabled && !stats_logging_enabled_) {
@@ skipping 20 matching lines @@
                       stats->round_trip_ms());
 
   client_status_logger_->LogStatistics(stats);
 
   jni_runtime_->network_task_runner()->PostDelayedTask(
       FROM_HERE, base::Bind(&ChromotingJniInstance::LogPerfStats, this),
       base::TimeDelta::FromMilliseconds(kPerfStatsIntervalMs));
 }
 
 }  // namespace remoting