Revert "Adding GCM support to the copresence component. The Copresence server can push directives (…

ppapi/proxy/plugin_dispatcher.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 "ppapi/proxy/plugin_dispatcher.h"
 
 #include <map>
 
 #include "base/compiler_specific.h"
 #include "base/debug/trace_event.h"
@@ skipping 205 matching lines @@
   // plugin making pepper calls on a different thread.
   ProxyAutoLock lock;
   TRACE_EVENT2("ppapi proxy", "PluginDispatcher::OnMessageReceived",
                "Class", IPC_MESSAGE_ID_CLASS(msg.type()),
                "Line", IPC_MESSAGE_ID_LINE(msg.type()));
 
   if (msg.routing_id() == MSG_ROUTING_CONTROL) {
     // Handle some plugin-specific control messages.
     bool handled = true;
     IPC_BEGIN_MESSAGE_MAP(PluginDispatcher, msg)
-      IPC_MESSAGE_HANDLER(PpapiMsg_IsInterfaceSupported,
-                          OnMsgIsInterfaceSupported)
+      IPC_MESSAGE_HANDLER(PpapiMsg_SupportsInterface, OnMsgSupportsInterface)
       IPC_MESSAGE_HANDLER(PpapiMsg_SetPreferences, OnMsgSetPreferences)
       IPC_MESSAGE_UNHANDLED(handled = false);
     IPC_END_MESSAGE_MAP()
     if (handled)
       return true;
   }
   return Dispatcher::OnMessageReceived(msg);
 }
 
 void PluginDispatcher::OnChannelError() {
@@ skipping 53 matching lines @@
        i != temp_map.end(); ++i) {
     if (i->second == this) {
       // Synthesize an "instance destroyed" message, this will notify the
       // plugin and also remove it from our list of tracked plugins.
       PpapiMsg_PPPInstance_DidDestroy msg(API_ID_PPP_INSTANCE, i->first);
       OnMessageReceived(msg);
     }
   }
 }
 
-void PluginDispatcher::OnMsgIsInterfaceSupported(
+void PluginDispatcher::OnMsgSupportsInterface(
     const std::string& interface_name,
     bool* result) {
   *result = !!GetPluginInterface(interface_name);
 
   // Do fallback for PPP_Instance. This is a hack here and if we have more
   // cases like this it should be generalized. The PPP_Instance proxy always
   // proxies the 1.1 interface, and then does fallback to 1.0 inside the
   // plugin process (see PPP_Instance_Proxy). So here we return true for
   // supporting the 1.1 interface if either 1.1 or 1.0 is supported.
   if (!*result && interface_name == PPP_INSTANCE_INTERFACE)
     *result = !!GetPluginInterface(PPP_INSTANCE_INTERFACE_1_0);
 }
 
 void PluginDispatcher::OnMsgSetPreferences(const Preferences& prefs) {
   // The renderer may send us preferences more than once (currently this
   // happens every time a new plugin instance is created). Since we don't have
   // a way to signal to the plugin that the preferences have changed, changing
   // the default fonts and such in the middle of a running plugin could be
   // confusing to it. As a result, we never allow the preferences to be changed
   // once they're set. The user will have to restart to get new font prefs
   // propogated to plugins.
   if (!received_preferences_) {
     received_preferences_ = true;
     preferences_ = prefs;
   }
 }
 
 }  // namespace proxy
 }  // namespace ppapi