Replace webkit/glue/screen_info.h with WebKit/chromium/public/WebScreenInfo.h...

chrome/common/render_messages.h

 // Copyright (c) 2006-2008 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.
 
 #ifndef CHROME_COMMON_RENDER_MESSAGES_H_
 #define CHROME_COMMON_RENDER_MESSAGES_H_
 
 #include <string>
 #include <vector>
 #include <map>
 
 #include "base/basictypes.h"
 #include "base/gfx/native_widget_types.h"
 #include "base/ref_counted.h"
 #include "base/shared_memory.h"
 #include "chrome/browser/renderer_host/resource_handler.h"
 #include "chrome/common/filter_policy.h"
 #include "chrome/common/ipc_message_utils.h"
 #include "chrome/common/modal_dialog_event.h"
 #include "chrome/common/page_transition_types.h"
 #include "chrome/common/transport_dib.h"
+#include "chrome/common/webkit_param_traits.h"
 #include "googleurl/src/gurl.h"
 #include "media/audio/audio_output.h"
 #include "net/base/upload_data.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request_status.h"
-#include "third_party/WebKit/WebKit/chromium/public/WebCache.h"
-#include "third_party/WebKit/WebKit/chromium/public/WebConsoleMessage.h"
-#include "third_party/WebKit/WebKit/chromium/public/WebFindInPageRequest.h"
-#include "third_party/WebKit/WebKit/chromium/public/WebInputEvent.h"
 #include "webkit/glue/autofill_form.h"
 #include "webkit/glue/context_menu.h"
 #include "webkit/glue/feed.h"
 #include "webkit/glue/form_data.h"
 #include "webkit/glue/password_form.h"
 #include "webkit/glue/password_form_dom_manager.h"
 #include "webkit/glue/resource_loader_bridge.h"
-#include "webkit/glue/screen_info.h"
 #include "webkit/glue/webaccessibility.h"
 #include "webkit/glue/webdropdata.h"
 #include "webkit/glue/webplugin.h"
 #include "webkit/glue/webpreferences.h"
 #include "webkit/glue/webview_delegate.h"
 
 #if defined(OS_POSIX)
 #include "skia/include/SkBitmap.h"
 #endif
 
@@ skipping 316 matching lines @@
   // Number of bits per sample;
   int bits_per_sample;
 
   // Number of bytes per packet.
   size_t packet_size;
 };
 
 namespace IPC {
 
 template <>
-struct ParamTraits<WebKit::WebString> {
-  typedef WebKit::WebString param_type;
-  static void Write(Message* m, const param_type& p) {
-    m->WriteData(reinterpret_cast<const char*>(p.data()),
-                 static_cast<int>(p.length() * sizeof(WebKit::WebUChar)));
-  }
-  static bool Read(const Message* m, void** iter, param_type* p) {
-    const char* data;
-    int data_len;
-    if (!m->ReadData(iter, &data, &data_len))
-      return false;
-    p->assign(reinterpret_cast<const WebKit::WebUChar*>(data),
-              static_cast<size_t>(data_len / sizeof(WebKit::WebUChar)));
-    return true;
-  }
-  static void Log(const param_type& p, std::wstring* l) {
-    l->append(UTF16ToWideHack(p));
-  }
-};
-
-template <>
-struct ParamTraits<WebKit::WebConsoleMessage::Level> {
-  typedef WebKit::WebConsoleMessage::Level param_type;
-  static void Write(Message* m, const param_type& p) {
-    WriteParam(m, static_cast<int>(p));
-  }
-  static bool Read(const Message* m, void** iter, param_type* r) {
-    int value;
-    if (!ReadParam(m, iter, &value))
-      return false;
-    *r = static_cast<param_type>(value);
-    return true;
-  }
-  static void Log(const param_type& p, std::wstring* l) {
-    LogParam(static_cast<int>(p), l);
-  }
-};
-
-template <>
-struct ParamTraits<WebKit::WebConsoleMessage> {
-  typedef WebKit::WebConsoleMessage param_type;
-  static void Write(Message* m, const param_type& p) {
-    WriteParam(m, p.level);
-    WriteParam(m, p.text);
-  }
-  static bool Read(const Message* m, void** iter, param_type* r) {
-    return
-      ReadParam(m, iter, &r->level) &&
-      ReadParam(m, iter, &r->text);
-  }
-  static void Log(const param_type& p, std::wstring* l) {
-    l->append(L"(");
-    LogParam(p.level, l);
-    l->append(L", ");
-    LogParam(p.text, l);
-    l->append(L")");
-  }
-};
-
-template <>
 struct ParamTraits<ResourceType::Type> {
   typedef ResourceType::Type param_type;
   static void Write(Message* m, const param_type& p) {
     m->WriteInt(p);
   }
   static bool Read(const Message* m, void** iter, param_type* p) {
     int type;
     if (!m->ReadInt(iter, &type) || !ResourceType::ValidType(type))
       return false;
     *p = ResourceType::FromInt(type);
@@ skipping 94 matching lines @@
         event.append(L"EDITABLE|");
       if (p.type & ContextNode::MISSPELLED_WORD)
         event.append(L"MISSPELLED_WORD|");
       event.append(L")");
     }
 
     LogParam(event, l);
   }
 };
 
-template <>
-struct ParamTraits<WebKit::WebInputEvent::Type> {
-  typedef WebKit::WebInputEvent::Type param_type;
-  static void Write(Message* m, const param_type& p) {
-    m->WriteInt(p);
-  }
-  static bool Read(const Message* m, void** iter, param_type* p) {
-    int type;
-    if (!m->ReadInt(iter, &type))
-      return false;
-    *p = static_cast<WebKit::WebInputEvent::Type>(type);
-    return true;
-  }
-  static void Log(const param_type& p, std::wstring* l) {
-    std::wstring type;
-    switch (p) {
-     case WebKit::WebInputEvent::MouseDown:
-      type = L"MouseDown";
-      break;
-     case WebKit::WebInputEvent::MouseUp:
-      type = L"MouseUp";
-      break;
-     case WebKit::WebInputEvent::MouseMove:
-      type = L"MouseMove";
-      break;
-     case WebKit::WebInputEvent::MouseLeave:
-      type = L"MouseLeave";
-      break;
-     case WebKit::WebInputEvent::MouseDoubleClick:
-      type = L"MouseDoubleClick";
-      break;
-     case WebKit::WebInputEvent::MouseWheel:
-      type = L"MouseWheel";
-      break;
-     case WebKit::WebInputEvent::RawKeyDown:
-      type = L"RawKeyDown";
-      break;
-     case WebKit::WebInputEvent::KeyDown:
-      type = L"KeyDown";
-      break;
-     case WebKit::WebInputEvent::KeyUp:
-      type = L"KeyUp";
-      break;
-     default:
-      type = L"None";
-      break;
-    }
-
-    LogParam(type, l);
-  }
-};
-
 // Traits for ViewHostMsg_UpdateFeedList_Params structure to pack/unpack.
 template <>
 struct ParamTraits<ViewHostMsg_UpdateFeedList_Params> {
   typedef ViewHostMsg_UpdateFeedList_Params param_type;
   static void Write(Message* msg, const param_type& param) {
     WriteParam(msg, param.page_id);
     WriteParam(msg, param.feedlist->list().size());
     for (std::vector<FeedItem>::const_iterator iter =
              param.feedlist->list().begin();
          iter != param.feedlist->list().end(); iter++) {
@@ skipping 642 matching lines @@
     *r = new net::UploadData;
     (*r)->swap_elements(&elements);
     (*r)->set_identifier(identifier);
     return true;
   }
   static void Log(const param_type& p, std::wstring* l) {
     l->append(L"<net::UploadData>");
   }
 };
 
-// Traits for WebKit::WebCache::UsageStats
-template <>
-struct ParamTraits<WebKit::WebCache::UsageStats> {
-  typedef WebKit::WebCache::UsageStats param_type;
-  static void Write(Message* m, const param_type& p) {
-    WriteParam(m, p.minDeadCapacity);
-    WriteParam(m, p.maxDeadCapacity);
-    WriteParam(m, p.capacity);
-    WriteParam(m, p.liveSize);
-    WriteParam(m, p.deadSize);
-  }
-  static bool Read(const Message* m, void** iter, param_type* r) {
-    return
-      ReadParam(m, iter, &r->minDeadCapacity) &&
-      ReadParam(m, iter, &r->maxDeadCapacity) &&
-      ReadParam(m, iter, &r->capacity) &&
-      ReadParam(m, iter, &r->liveSize) &&
-      ReadParam(m, iter, &r->deadSize);
-  }
-  static void Log(const param_type& p, std::wstring* l) {
-    l->append(L"<WebCache::UsageStats>");
-  }
-};
-
-template <>
-struct ParamTraits<WebKit::WebCache::ResourceTypeStat> {
-  typedef WebKit::WebCache::ResourceTypeStat param_type;
-  static void Write(Message* m, const param_type& p) {
-    WriteParam(m, p.count);
-    WriteParam(m, p.size);
-    WriteParam(m, p.liveSize);
-    WriteParam(m, p.decodedSize);
-  }
-  static bool Read(const Message* m, void** iter, param_type* r) {
-    bool result =
-        ReadParam(m, iter, &r->count) &&
-        ReadParam(m, iter, &r->size) &&
-        ReadParam(m, iter, &r->liveSize) &&
-        ReadParam(m, iter, &r->decodedSize);
-    return result;
-  }
-  static void Log(const param_type& p, std::wstring* l) {
-    l->append(StringPrintf(L"%d %d %d %d", p.count, p.size, p.liveSize,
-        p.decodedSize));
-  }
-};
-
-template <>
-struct ParamTraits<WebKit::WebCache::ResourceTypeStats> {
-  typedef WebKit::WebCache::ResourceTypeStats param_type;
-  static void Write(Message* m, const param_type& p) {
-    WriteParam(m, p.images);
-    WriteParam(m, p.cssStyleSheets);
-    WriteParam(m, p.scripts);
-    WriteParam(m, p.xslStyleSheets);
-    WriteParam(m, p.fonts);
-  }
-  static bool Read(const Message* m, void** iter, param_type* r) {
-    bool result =
-      ReadParam(m, iter, &r->images) &&
-      ReadParam(m, iter, &r->cssStyleSheets) &&
-      ReadParam(m, iter, &r->scripts) &&
-      ReadParam(m, iter, &r->xslStyleSheets) &&
-      ReadParam(m, iter, &r->fonts);
-    return result;
-  }
-  static void Log(const param_type& p, std::wstring* l) {
-    l->append(L"<WebCoreStats>");
-    LogParam(p.images, l);
-    LogParam(p.cssStyleSheets, l);
-    LogParam(p.scripts, l);
-    LogParam(p.xslStyleSheets, l);
-    LogParam(p.fonts, l);
-    l->append(L"</WebCoreStats>");
-  }
-};
-
 // Traits for PasswordFormDomManager::FillData.
 template <>
 struct ParamTraits<PasswordFormDomManager::FillData> {
   typedef PasswordFormDomManager::FillData param_type;
   static void Write(Message* m, const param_type& p) {
     WriteParam(m, p.basic_data);
     WriteParam(m, p.additional_logins);
     WriteParam(m, p.wait_for_username);
   }
   static bool Read(const Message* m, void** iter, param_type* r) {
@@ skipping 453 matching lines @@
       ReadParam(m, iter, &p->text_html) &&
       ReadParam(m, iter, &p->html_base_url) &&
       ReadParam(m, iter, &p->file_description_filename) &&
       ReadParam(m, iter, &p->file_contents);
   }
   static void Log(const param_type& p, std::wstring* l) {
     l->append(L"<WebDropData>");
   }
 };
 
-// Traits for ScreenInfo
-template <>
-struct ParamTraits<webkit_glue::ScreenInfo> {
-  typedef webkit_glue::ScreenInfo param_type;
-  static void Write(Message* m, const param_type& p) {
-    WriteParam(m, p.depth);
-    WriteParam(m, p.depth_per_component);
-    WriteParam(m, p.is_monochrome);
-    WriteParam(m, p.rect);
-    WriteParam(m, p.available_rect);
-  }
-  static bool Read(const Message* m, void** iter, param_type* p) {
-    return
-      ReadParam(m, iter, &p->depth) &&
-      ReadParam(m, iter, &p->depth_per_component) &&
-      ReadParam(m, iter, &p->is_monochrome) &&
-      ReadParam(m, iter, &p->rect) &&
-      ReadParam(m, iter, &p->available_rect);
-  }
-  static void Log(const param_type& p, std::wstring* l) {
-    l->append(L"<webkit_glue::ScreenInfo>");
-  }
-};
-
 template<>
 struct ParamTraits<ModalDialogEvent> {
   typedef ModalDialogEvent param_type;
 #if defined(OS_WIN)
   static void Write(Message* m, const param_type& p) {
     WriteParam(m, p.event);
   }
   static bool Read(const Message* m, void** iter, param_type* p) {
     return ReadParam(m, iter, &p->event);
   }
@@ skipping 131 matching lines @@
        break;
      default:
       state = L"UNKNOWN";
       break;
     }
 
     LogParam(state, l);
   }
 };
 
-template <>
-struct ParamTraits<WebKit::WebFindInPageRequest> {
-  typedef WebKit::WebFindInPageRequest param_type;
-  static void Write(Message* m, const param_type& p) {
-    WriteParam(m, p.identifier);
-    WriteParam(m, p.text);
-    WriteParam(m, p.forward);
-    WriteParam(m, p.matchCase);
-    WriteParam(m, p.findNext);
-  }
-  static bool Read(const Message* m, void** iter, param_type* p) {
-    return
-      ReadParam(m, iter, &p->identifier) &&
-      ReadParam(m, iter, &p->text) &&
-      ReadParam(m, iter, &p->forward) &&
-      ReadParam(m, iter, &p->matchCase) &&
-      ReadParam(m, iter, &p->findNext);
-  }
-  static void Log(const param_type& p, std::wstring* l) {
-    l->append(L"<FindInPageRequest>");
-  }
-};
-
 }  // namespace IPC
 
 
 #define MESSAGES_INTERNAL_FILE "chrome/common/render_messages_internal.h"
 #include "chrome/common/ipc_message_macros.h"
 
 #endif  // CHROME_COMMON_RENDER_MESSAGES_H_