Simplify FrameConsumer interface. Remove FrameProducer interface.

remoting/client/jni/chromoting_jni_instance.h

 // 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.
 
 #ifndef REMOTING_CLIENT_CHROMOTING_JNI_INSTANCE_H_
 #define REMOTING_CLIENT_CHROMOTING_JNI_INSTANCE_H_
 
 #include <string>
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "remoting/client/chromoting_client.h"
 #include "remoting/client/client_context.h"
 #include "remoting/client/client_user_interface.h"
-#include "remoting/client/frame_consumer_proxy.h"
-#include "remoting/client/jni/jni_frame_consumer.h"
 #include "remoting/protocol/clipboard_stub.h"
 #include "remoting/protocol/cursor_shape_stub.h"
 #include "remoting/signaling/xmpp_signal_strategy.h"
 
 namespace remoting {
 
 namespace protocol {
 class ClipboardEvent;
 class CursorShapeInfo;
 }  // namespace protocol
 
+class ChromotingJniRuntime;
 class ClientStatusLogger;
+class JniFrameConsumer;
+class TokenFetcherProxy;
 class VideoRenderer;
-class TokenFetcherProxy;
 
 // ClientUserInterface that indirectly makes and receives JNI calls.
 class ChromotingJniInstance
   : public ClientUserInterface,
     public protocol::ClipboardStub,
     public protocol::CursorShapeStub,
     public base::RefCountedThreadSafe<ChromotingJniInstance> {
  public:
   // Initiates a connection with the specified host. Call from the UI thread.
   // The instance does not take ownership of |jni_runtime|. To connect with an
@@ skipping 68 matching lines @@
   // CursorShapeStub implementation.
   void InjectClipboardEvent(const protocol::ClipboardEvent& event) override;
 
   // ClipboardStub implementation.
   void SetCursorShape(const protocol::CursorShapeInfo& shape) override;
 
  private:
   // This object is ref-counted, so it cleans itself up.
   ~ChromotingJniInstance() override;
 
-  void ConnectToHostOnDisplayThread();
-  void ConnectToHostOnNetworkThread(
-      scoped_ptr<FrameConsumerProxy> frame_consumer);
-  void DisconnectFromHostOnNetworkThread();
+  void ConnectToHostOnNetworkThread();
 
   // Notifies the user interface that the user needs to enter a PIN. The
   // current authentication attempt is put on hold until |callback| is invoked.
   // May be called on any thread.
   void FetchSecret(bool pairable,
                    const protocol::SecretFetchedCallback& callback);
 
   // Sets the device name. Can be called on any thread.
   void SetDeviceName(const std::string& device_name);
 
   void SendKeyEventInternal(int usb_key_code, bool key_down);
 
   // Enables or disables periodic logging of performance statistics. Called on
   // the network thread.
   void EnableStatsLogging(bool enabled);
 
   // If logging is enabled, logs the current connection statistics, and
   // triggers another call to this function after the logging time interval.
   // Called on the network thread.
   void LogPerfStats();
 
   // Used to obtain task runner references and make calls to Java methods.
   ChromotingJniRuntime* jni_runtime_;
 
   // ID of the host we are connecting to.
   std::string host_id_;
   std::string host_jid_;
 
-  // This group of variables is to be used on the display thread.
-  scoped_ptr<JniFrameConsumer> view_;
-  scoped_ptr<base::WeakPtrFactory<JniFrameConsumer>> view_weak_factory_;
-
   // This group of variables is to be used on the network thread.
   scoped_ptr<ClientContext> client_context_;
+  scoped_ptr<JniFrameConsumer> view_;
   scoped_ptr<VideoRenderer> video_renderer_;
   scoped_ptr<protocol::Authenticator> authenticator_;
   scoped_ptr<ChromotingClient> client_;
   XmppSignalStrategy::XmppServerConfig xmpp_config_;
   scoped_ptr<XmppSignalStrategy> signaling_;  // Must outlive client_
   scoped_ptr<ClientStatusLogger> client_status_logger_;
   base::WeakPtr<TokenFetcherProxy> token_fetcher_proxy_;
 
   // Pass this the user's PIN once we have it. To be assigned and accessed on
   // the UI thread, but must be posted to the network thread to call it.
@@ skipping 21 matching lines @@
   friend class base::RefCountedThreadSafe<ChromotingJniInstance>;
 
   base::WeakPtrFactory<ChromotingJniInstance> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ChromotingJniInstance);
 };
 
 }  // namespace remoting
 
 #endif