Revert 69755 - Move the NPAPI files from webkit/glue/plugins to webkit/plugin...

chrome/common/render_messages.cc

 // Copyright (c) 2010 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 "base/values.h"
 #include "chrome/common/edit_command.h"
 #include "chrome/common/extensions/extension_extent.h"
 #include "chrome/common/extensions/url_pattern.h"
 #include "chrome/common/gpu_param_traits.h"
 #include "chrome/common/render_messages_params.h"
 #include "chrome/common/resource_response.h"
 #include "chrome/common/speech_input_result.h"
 #include "chrome/common/thumbnail_score.h"
 #include "chrome/common/web_apps.h"
 #include "gfx/rect.h"
 #include "ipc/ipc_channel_handle.h"
 #include "media/audio/audio_buffers_state.h"
 #include "net/base/upload_data.h"
 #include "net/http/http_response_headers.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebCompositionUnderline.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "webkit/appcache/appcache_interfaces.h"
 #include "webkit/blob/blob_data.h"
 #include "webkit/glue/form_field.h"
 #include "webkit/glue/password_form.h"
+#include "webkit/glue/plugins/webplugin.h"
 #include "webkit/glue/resource_loader_bridge.h"
 #include "webkit/glue/webaccessibility.h"
 #include "webkit/glue/webcookie.h"
 #include "webkit/glue/webcursor.h"
 #include "webkit/glue/webmenuitem.h"
-#include "webkit/plugins/npapi/webplugin.h"
 
 #if defined(OS_MACOSX)
 #include "chrome/common/font_descriptor_mac.h"
 #endif
 
 #define IPC_MESSAGE_IMPL
 #include "chrome/common/render_messages.h"
 
 namespace IPC {
 
@@ skipping 147 matching lines @@
       ReadParam(m, iter, &p->security_info) &&
       ReadParam(m, iter, &p->frame_charset) &&
       ReadParam(m, iter, &p->custom_items);
 }
 
 void ParamTraits<ContextMenuParams>::Log(const param_type& p,
                                          std::string* l) {
   l->append("<ContextMenuParams>");
 }
 
-void ParamTraits<webkit::npapi::WebPluginGeometry>::Write(Message* m,
-                                                          const param_type& p) {
+void ParamTraits<webkit_glue::WebPluginGeometry>::Write(Message* m,
+                                                        const param_type& p) {
   WriteParam(m, p.window);
   WriteParam(m, p.window_rect);
   WriteParam(m, p.clip_rect);
   WriteParam(m, p.cutout_rects);
   WriteParam(m, p.rects_valid);
   WriteParam(m, p.visible);
 }
 
-bool ParamTraits<webkit::npapi::WebPluginGeometry>::Read(
+bool ParamTraits<webkit_glue::WebPluginGeometry>::Read(
     const Message* m, void** iter, param_type* p) {
   return
       ReadParam(m, iter, &p->window) &&
       ReadParam(m, iter, &p->window_rect) &&
       ReadParam(m, iter, &p->clip_rect) &&
       ReadParam(m, iter, &p->cutout_rects) &&
       ReadParam(m, iter, &p->rects_valid) &&
       ReadParam(m, iter, &p->visible);
 }
 
-void ParamTraits<webkit::npapi::WebPluginGeometry>::Log(const param_type& p,
-                                                        std::string* l) {
+void ParamTraits<webkit_glue::WebPluginGeometry>::Log(const param_type& p,
+                                                      std::string* l) {
   l->append("(");
   LogParam(p.window, l);
   l->append(", ");
   LogParam(p.window_rect, l);
   l->append(", ");
   LogParam(p.clip_rect, l);
   l->append(", ");
   LogParam(p.cutout_rects, l);
   l->append(", ");
   LogParam(p.rects_valid, l);
   l->append(", ");
   LogParam(p.visible, l);
   l->append(")");
 }
 
-void ParamTraits<webkit::npapi::WebPluginMimeType>::Write(Message* m,
-                                                          const param_type& p) {
+void ParamTraits<WebPluginMimeType>::Write(Message* m, const param_type& p) {
   WriteParam(m, p.mime_type);
   WriteParam(m, p.file_extensions);
   WriteParam(m, p.description);
 }
 
-bool ParamTraits<webkit::npapi::WebPluginMimeType>::Read(const Message* m,
-                                                         void** iter,
-                                                         param_type* r) {
+bool ParamTraits<WebPluginMimeType>::Read(const Message* m, void** iter,
+                                          param_type* r) {
   return
       ReadParam(m, iter, &r->mime_type) &&
       ReadParam(m, iter, &r->file_extensions) &&
       ReadParam(m, iter, &r->description);
 }
 
-void ParamTraits<webkit::npapi::WebPluginMimeType>::Log(const param_type& p,
-                                                        std::string* l) {
+void ParamTraits<WebPluginMimeType>::Log(const param_type& p, std::string* l) {
   l->append("(");
   LogParam(p.mime_type, l);
   l->append(", ");
   LogParam(p.file_extensions, l);
   l->append(", ");
   LogParam(p.description, l);
   l->append(")");
 }
 
-void ParamTraits<webkit::npapi::WebPluginInfo>::Write(Message* m,
-                                                      const param_type& p) {
+void ParamTraits<WebPluginInfo>::Write(Message* m, const param_type& p) {
   WriteParam(m, p.name);
   WriteParam(m, p.path);
   WriteParam(m, p.version);
   WriteParam(m, p.desc);
   WriteParam(m, p.mime_types);
   WriteParam(m, p.enabled);
 }
 
-bool ParamTraits<webkit::npapi::WebPluginInfo>::Read(const Message* m,
-                                                     void** iter,
-                                                     param_type* r) {
+bool ParamTraits<WebPluginInfo>::Read(const Message* m, void** iter,
+                                      param_type* r) {
   return
       ReadParam(m, iter, &r->name) &&
       ReadParam(m, iter, &r->path) &&
       ReadParam(m, iter, &r->version) &&
       ReadParam(m, iter, &r->desc) &&
       ReadParam(m, iter, &r->mime_types) &&
       ReadParam(m, iter, &r->enabled);
 }
 
-void ParamTraits<webkit::npapi::WebPluginInfo>::Log(const param_type& p,
-                                                    std::string* l) {
+void ParamTraits<WebPluginInfo>::Log(const param_type& p, std::string* l) {
   l->append("(");
   LogParam(p.name, l);
   l->append(", ");
   l->append(", ");
   LogParam(p.path, l);
   l->append(", ");
   LogParam(p.version, l);
   l->append(", ");
   LogParam(p.desc, l);
   l->append(", ");
@@ skipping 932 matching lines @@
 void ParamTraits<speech_input::SpeechInputResultItem>::Log(const param_type& p,
                                                            std::string* l) {
   l->append("(");
   LogParam(p.utterance, l);
   l->append(":");
   LogParam(p.confidence, l);
   l->append(")");
 }
 
 }  // namespace IPC