Add notifyClientDimensions API to the Chromoting Client plugin.

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 84 matching lines @@
 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;
 
 static base::LazyInstance<base::Lock>::Leaky
     g_logging_lock = LAZY_INSTANCE_INITIALIZER;
 
 // String sent in the "hello" message to the plugin to describe features.
 const char ChromotingInstance::kApiFeatures[] =
-    "highQualityScaling injectKeyEvent sendClipboardItem remapKey trapKey";
+    "highQualityScaling injectKeyEvent sendClipboardItem remapKey trapKey "
+    "notifyClientDimensions";
 
 bool ChromotingInstance::ParseAuthMethods(const std::string& auth_methods_str,
                                           ClientConfig* config) {
   if (auth_methods_str == "v1_token") {
     config->use_v1_authenticator = true;
   } else {
     config->use_v1_authenticator = false;
 
     std::vector<std::string> auth_methods;
     base::SplitString(auth_methods_str, ',', &auth_methods);
@@ skipping 176 matching lines @@
     TrapKey(keycode, trap);
   } else if (method == "sendClipboardItem") {
     std::string mime_type;
     std::string item;
     if (!data->GetString("mimeType", &mime_type) ||
         !data->GetString("item", &item)) {
       LOG(ERROR) << "Invalid sendClipboardItem() data.";
       return;
     }
     SendClipboardItem(mime_type, item);
+  } else if (method == "notifyClientDimensions") {
+    int width = 0;
+    int height = 0;
+    if (!data->GetInteger("width", &width) ||
+        !data->GetInteger("height", &height)) {
+      LOG(ERROR) << "Invalid notifyClientDimensions.";
+      return;
+    }
+    NotifyClientDimensions(width, height);
   }
 }
 
 void ChromotingInstance::DidChangeView(const pp::Rect& position,
                                        const pp::Rect& clip) {
   DCHECK(plugin_message_loop_->BelongsToCurrentThread());
 
   SkISize new_size = SkISize::Make(position.width(), position.height());
   SkIRect new_clip =
     SkIRect::MakeXYWH(clip.x(), clip.y(), clip.width(), clip.height());
@@ skipping 153 matching lines @@
                                            const std::string& item) {
   if (!host_connection_.get()) {
     return;
   }
   protocol::ClipboardEvent event;
   event.set_mime_type(mime_type);
   event.set_data(item);
   host_connection_->clipboard_stub()->InjectClipboardEvent(event);
 }
 
+void ChromotingInstance::NotifyClientDimensions(int width, int height) {
+  if (!host_connection_.get()) {
+    return;
+  }
+  protocol::ClientDimensions client_dimensions;
+  client_dimensions.set_width(width);
+  client_dimensions.set_height(height);
+  host_connection_->host_stub()->NotifyClientDimensions(client_dimensions);
+}
+
 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 143 matching lines @@
     scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
     data->SetString("message", message);
     PostChromotingMessage("logDebugMessage", data.Pass());
 
     scriptable_object->LogDebugInfo(message);
   }
   g_logging_to_plugin = false;
 }
 
 }  // namespace remoting