Refactoring of the client-side input pipeline and scaling dimension management.

remoting/client/plugin/chromoting_instance.cc

 // Copyright (c) 2011 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/plugin/chromoting_instance.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/stringprintf.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "media/base/media.h"
 #include "ppapi/cpp/completion_callback.h"
 #include "ppapi/cpp/input_event.h"
 #include "ppapi/cpp/rect.h"
 // TODO(wez): Remove this when crbug.com/86353 is complete.
 #include "ppapi/cpp/private/var_private.h"
 #include "remoting/base/util.h"
 #include "remoting/client/client_config.h"
 #include "remoting/client/chromoting_client.h"
+#include "remoting/client/mouse_input_filter.h"
 #include "remoting/client/plugin/chromoting_scriptable_object.h"
 #include "remoting/client/plugin/pepper_input_handler.h"
 #include "remoting/client/plugin/pepper_view.h"
-#include "remoting/client/plugin/pepper_view_proxy.h"
 #include "remoting/client/plugin/pepper_xmpp_proxy.h"
 #include "remoting/client/rectangle_update_decoder.h"
 #include "remoting/protocol/connection_to_host.h"
 #include "remoting/protocol/host_stub.h"
+#include "remoting/protocol/key_event_tracker.h"
 
 namespace remoting {
 
 // This flag blocks LOGs to the UI if we're already in the middle of logging
 // to the UI. This prevents a potential infinite loop if we encounter an error
 // while sending the log message to the UI.
 static bool g_logging_to_plugin = false;
 static bool g_has_logging_instance = false;
 static ChromotingInstance* g_logging_instance = NULL;
 static logging::LogMessageHandlerFunction g_logging_old_handler = NULL;
@@ skipping 30 matching lines @@
   // to it. This will stop all logging in all Chromoting instances.
   UnregisterLoggingInstance();
 
   if (client_.get()) {
     base::WaitableEvent done_event(true, false);
     client_->Stop(base::Bind(&base::WaitableEvent::Signal,
                              base::Unretained(&done_event)));
     done_event.Wait();
   }
 
-  // Stopping the context shutdown all chromoting threads. This is a requirement
-  // before we can call Detach() on |view_proxy_|.
+  // Stopping the context shuts down all chromoting threads.
   context_.Stop();
 
-  if (view_proxy_.get()) {
-    view_proxy_->Detach();
-  }
-
   // Delete |thread_proxy_| before we detach |plugin_message_loop_|,
-  // otherwise ScopedThreadProxy may DCHECK when destroying.
+  // otherwise ScopedThreadProxy may DCHECK when being destroyed.
   thread_proxy_.reset();
 
   plugin_message_loop_->Detach();
 }
 
 bool ChromotingInstance::Init(uint32_t argc,
                               const char* argn[],
                               const char* argv[]) {
   CHECK(!initialized_);
   initialized_ = true;
 
   VLOG(1) << "Started ChromotingInstance::Init";
 
   // Check to make sure the media library is initialized.
   // http://crbug.com/91521.
   if (!media::IsMediaLibraryInitialized()) {
     LOG(ERROR) << "Media library not initialized.";
     return false;
   }
 
   // Start all the threads.
   context_.Start();
 
   // Create the chromoting objects that don't depend on the network connection.
   view_.reset(new PepperView(this, &context_));
-  view_proxy_ = new PepperViewProxy(this, view_.get(), plugin_message_loop_);
   rectangle_decoder_ = new RectangleUpdateDecoder(
-      context_.decode_message_loop(), view_proxy_);
+      context_.decode_message_loop(), view_.get());
 
   // Default to a medium grey.
   view_->SetSolidFill(0xFFCDCDCD);
 
   return true;
 }
 
 void ChromotingInstance::Connect(const ClientConfig& config) {
   DCHECK(plugin_message_loop_->BelongsToCurrentThread());
 
   host_connection_.reset(new protocol::ConnectionToHost(
       context_.network_message_loop(), this, true));
-
-  input_handler_.reset(new PepperInputHandler(&context_,
-                                              host_connection_.get(),
-                                              view_proxy_));
-
   client_.reset(new ChromotingClient(config, &context_, host_connection_.get(),
-                                     view_proxy_, rectangle_decoder_.get(),
-                                     input_handler_.get(), base::Closure()));
+                                     view_.get(), rectangle_decoder_.get(),
+                                     base::Closure()));
 
   LOG(INFO) << "Connecting to " << config.host_jid
             << ". Local jid: " << config.local_jid << ".";
 
   // Setup the XMPP Proxy.
   ChromotingScriptableObject* scriptable_object = GetScriptableObject();
   scoped_refptr<PepperXmppProxy> xmpp_proxy =
       new PepperXmppProxy(scriptable_object->AsWeakPtr(),
                           plugin_message_loop_,
                           context_.network_message_loop());
@@ skipping 15 matching lines @@
   if (client_.get()) {
     // TODO(sergeyu): Should we disconnect asynchronously?
     base::WaitableEvent done_event(true, false);
     client_->Stop(base::Bind(&base::WaitableEvent::Signal,
                              base::Unretained(&done_event)));
     done_event.Wait();
     client_.reset();
   }
 
   input_handler_.reset();
+  key_event_tracker_.reset();
+  mouse_input_filter_.reset();
   host_connection_.reset();
 
   GetScriptableObject()->SetConnectionStatus(
       ChromotingScriptableObject::STATUS_CLOSED,
       ChromotingScriptableObject::ERROR_NONE);
 }
 
 void ChromotingInstance::DidChangeView(const pp::Rect& position,
                                        const pp::Rect& clip) {
   DCHECK(plugin_message_loop_->BelongsToCurrentThread());
 
-  view_->SetPluginSize(SkISize::Make(position.width(), position.height()));
-
-  // TODO(wez): Pass the dimensions of the plugin to the RectangleDecoder
-  //            and let it generate the necessary refresh events.
-  // If scale-to-fit is enabled then update the scaling ratios.
-  // We also force a full-frame refresh, in case the ratios changed.
-  if (scale_to_fit_) {
-    rectangle_decoder_->SetScaleRatios(view_->GetHorizontalScaleRatio(),
-                                       view_->GetVerticalScaleRatio());
-    rectangle_decoder_->RefreshFullFrame();
+  SkISize new_size = SkISize::Make(position.width(), position.height());
+  if (view_->SetViewSize(new_size)) {
+    if (mouse_input_filter_.get()) {
+      mouse_input_filter_->set_input_size(new_size);
+    }
+    rectangle_decoder_->SetOutputSize(new_size);
   }
 
-  // Notify the RectangleDecoder of the new clip rect.
   rectangle_decoder_->UpdateClipRect(
       SkIRect::MakeXYWH(clip.x(), clip.y(), clip.width(), clip.height()));
 }
 
 bool ChromotingInstance::HandleInputEvent(const pp::InputEvent& event) {
   DCHECK(plugin_message_loop_->BelongsToCurrentThread());
-  if (!input_handler_.get()) {
+
+  // Never inject events if the end of the input pipeline doesn't exist.
+  // If it does exist but the pipeline doesn't, construct a pipeline.
+  // TODO(wez): This is really ugly.  We should create the pipeline when
+  // the ConnectionToHost's InputStub exists.
+  if (!host_connection_.get()) {
     return false;
+  } else if (!input_handler_.get()) {
+    protocol::InputStub* input_stub = host_connection_->input_stub();
+    if (!input_stub)
+      return false;
+    mouse_input_filter_.reset(new MouseInputFilter(input_stub));
+    mouse_input_filter_->set_input_size(view_->get_view_size());
+    key_event_tracker_.reset(
+        new protocol::KeyEventTracker(mouse_input_filter_.get()));
+    input_handler_.reset(
+        new PepperInputHandler(key_event_tracker_.get()));
   }
 
-  PepperInputHandler* pih
-      = static_cast<PepperInputHandler*>(input_handler_.get());
+  // TODO(wez): When we have a good hook into Host dimensions changes, move
+  // this there.
+  mouse_input_filter_->set_output_size(view_->get_host_size());
 
-  switch (event.GetType()) {
-    case PP_INPUTEVENT_TYPE_MOUSEDOWN: {
-      pih->HandleMouseButtonEvent(true, pp::MouseInputEvent(event));
-      return true;
-    }
-
-    case PP_INPUTEVENT_TYPE_MOUSEUP: {
-      pih->HandleMouseButtonEvent(false, pp::MouseInputEvent(event));
-      return true;
-    }
-
-    case PP_INPUTEVENT_TYPE_MOUSEMOVE:
-    case PP_INPUTEVENT_TYPE_MOUSEENTER:
-    case PP_INPUTEVENT_TYPE_MOUSELEAVE: {
-      pih->HandleMouseMoveEvent(pp::MouseInputEvent(event));
-      return true;
-    }
-
-    case PP_INPUTEVENT_TYPE_WHEEL: {
-      pih->HandleMouseWheelEvent(pp::WheelInputEvent(event));
-      return true;
-    }
-
-    case PP_INPUTEVENT_TYPE_CONTEXTMENU: {
-      // We need to return true here or else we'll get a local (plugin) context
-      // menu instead of the mouseup event for the right click.
-      return true;
-    }
-
-    case PP_INPUTEVENT_TYPE_KEYDOWN: {
-      pp::KeyboardInputEvent key = pp::KeyboardInputEvent(event);
-      VLOG(3) << "PP_INPUTEVENT_TYPE_KEYDOWN" << " key=" << key.GetKeyCode();
-      pih->HandleKeyEvent(true, key);
-      return true;
-    }
-
-    case PP_INPUTEVENT_TYPE_KEYUP: {
-      pp::KeyboardInputEvent key = pp::KeyboardInputEvent(event);
-      VLOG(3) << "PP_INPUTEVENT_TYPE_KEYUP" << " key=" << key.GetKeyCode();
-      pih->HandleKeyEvent(false, key);
-      return true;
-    }
-
-    case PP_INPUTEVENT_TYPE_CHAR: {
-      pih->HandleCharacterEvent(pp::KeyboardInputEvent(event));
-      return true;
-    }
-
-    default: {
-      LOG(INFO) << "Unhandled input event: " << event.GetType();
-      break;
-    }
-  }
-
-  return false;
+  return input_handler_->HandleInputEvent(event);
 }
 
 ChromotingScriptableObject* ChromotingInstance::GetScriptableObject() {
   pp::VarPrivate object = GetInstanceObject();
   if (!object.is_undefined()) {
     pp::deprecated::ScriptableObject* so = object.AsScriptableObject();
     DCHECK(so != NULL);
     return static_cast<ChromotingScriptableObject*>(so);
   }
   LOG(ERROR) << "Unable to get ScriptableObject for Chromoting plugin.";
   return NULL;
 }
 
-void ChromotingInstance::SetScaleToFit(bool scale_to_fit) {
-  DCHECK(plugin_message_loop_->BelongsToCurrentThread());
-
-  if (scale_to_fit == scale_to_fit_)
-    return;
-
-  scale_to_fit_ = scale_to_fit;
-  if (scale_to_fit) {
-    rectangle_decoder_->SetScaleRatios(view_->GetHorizontalScaleRatio(),
-                                       view_->GetVerticalScaleRatio());
-  } else {
-    rectangle_decoder_->SetScaleRatios(1.0, 1.0);
-  }
-
-  // TODO(wez): The RectangleDecoder should generate refresh events
-  //            as necessary in response to any scaling change.
-  rectangle_decoder_->RefreshFullFrame();
-}
-
 // static
 void ChromotingInstance::RegisterLogMessageHandler() {
   base::AutoLock lock(g_logging_lock.Get());
 
   VLOG(1) << "Registering global log handler";
 
   // Record previous handler so we can call it in a chain.
   g_logging_old_handler = logging::GetLogMessageHandler();
 
   // Set up log message handler.
@@ skipping 84 matching lines @@
   return instance_object_;
 }
 
 ChromotingStats* ChromotingInstance::GetStats() {
   if (!client_.get())
     return NULL;
   return client_->GetStats();
 }
 
 void ChromotingInstance::ReleaseAllKeys() {
-  if (!input_handler_.get()) {
-    return;
+  if (key_event_tracker_.get()) {
+    key_event_tracker_->ReleaseAllKeys();
   }
-
-  input_handler_->ReleaseAllKeys();
 }
 
 }  // namespace remoting