Added JsonMessage to the control channel.

remoting/client/plugin/chromoting_instance.cc

 // Copyright (c) 2012 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"
@@ skipping 126 matching lines @@
 base::LazyInstance<base::Lock>::Leaky
     g_logging_lock = LAZY_INSTANCE_INITIALIZER;
 logging::LogMessageHandlerFunction g_logging_old_handler = NULL;
 
 }  // namespace
 
 // String sent in the "hello" message to the webapp to describe features.
 const char ChromotingInstance::kApiFeatures[] =
     "highQualityScaling injectKeyEvent sendClipboardItem remapKey trapKey "
     "notifyClientDimensions notifyClientResolution pauseVideo pauseAudio "
-    "asyncPin thirdPartyAuth pinlessAuth";
+    "asyncPin thirdPartyAuth pinlessAuth extensionMessage";
 
 const char ChromotingInstance::kRequestedCapabilities[] = "";
 const char ChromotingInstance::kSupportedCapabilities[] = "desktopShape";
 
 bool ChromotingInstance::ParseAuthMethods(const std::string& auth_methods_str,
                                           ClientConfig* config) {
   std::vector<std::string> auth_methods;
   base::SplitString(auth_methods_str, ',', &auth_methods);
   for (std::vector<std::string>::iterator it = auth_methods.begin();
        it != auth_methods.end(); ++it) {
@@ skipping 268 matching lines @@
       return;
     }
     OnThirdPartyTokenFetched(token, shared_secret);
   } else if (method == "requestPairing") {
     std::string client_name;
     if (!data->GetString("clientName", &client_name)) {
       LOG(ERROR) << "Invalid requestPairing";
       return;
     }
     RequestPairing(client_name);
+  } else if (method == "extensionMessage") {
+    std::string type, message;
+    if (!data->GetString("type", &type) || !data->GetString("data", &message)) {
+      LOG(ERROR) << "Invalid extensionMessage.";
+      return;
+    }
+    SendClientMessage(type, message);
   }
 }
 
 void ChromotingInstance::DidChangeView(const pp::View& view) {
   DCHECK(plugin_task_runner_->BelongsToCurrentThread());
 
   plugin_view_ = view;
   if (view_) {
     view_->SetView(view);
     mouse_input_filter_.set_input_size(view_->get_view_size_dips());
@@ skipping 84 matching lines @@
 }
 
 void ChromotingInstance::SetPairingResponse(
     const protocol::PairingResponse& pairing_response) {
   scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
   data->SetString("clientId", pairing_response.client_id());
   data->SetString("sharedSecret", pairing_response.shared_secret());
   PostChromotingMessage("pairingResponse", data.Pass());
 }
 
+void ChromotingInstance::DeliverHostMessage(
+    const protocol::ExtensionMessage& message) {
+  scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
+  data->SetString("type", message.type());
+  data->SetString("data", message.data());
+  PostChromotingMessage("extensionMessage", data.Pass());
+}
+
 void ChromotingInstance::FetchSecretFromDialog(
     bool pairing_supported,
     const protocol::SecretFetchedCallback& secret_fetched_callback) {
   // Once the Session object calls this function, it won't continue the
   // authentication until the callback is called (or connection is canceled).
   // So, it's impossible to reach this with a callback already registered.
   DCHECK(secret_fetched_callback_.is_null());
   secret_fetched_callback_ = secret_fetched_callback;
   scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
   data->SetBoolean("pairingSupported", pairing_supported);
@@ skipping 282 matching lines @@
 
 void ChromotingInstance::RequestPairing(const std::string& client_name) {
   if (!IsConnected()) {
     return;
   }
   protocol::PairingRequest pairing_request;
   pairing_request.set_client_name(client_name);
   host_connection_->host_stub()->RequestPairing(pairing_request);
 }
 
+void ChromotingInstance::SendClientMessage(const std::string& type,
+                                           const std::string& data) {
+  if (!IsConnected()) {
+    return;
+  }
+  protocol::ExtensionMessage message;
+  message.set_type(type);
+  message.set_data(data);
+  host_connection_->host_stub()->DeliverClientMessage(message);
+}
+
 ChromotingStats* ChromotingInstance::GetStats() {
   if (!client_.get())
     return NULL;
   return client_->GetStats();
 }
 
 void ChromotingInstance::PostChromotingMessage(
     const std::string& method,
     scoped_ptr<base::DictionaryValue> data) {
   scoped_ptr<base::DictionaryValue> message(new base::DictionaryValue());
@@ skipping 157 matching lines @@
                                       url_components.scheme.len);
   return url_scheme == kChromeExtensionUrlScheme;
 }
 
 bool ChromotingInstance::IsConnected() {
   return host_connection_.get() &&
     (host_connection_->state() == protocol::ConnectionToHost::CONNECTED);
 }
 
 }  // namespace remoting