content/common/input/input_param_traits.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/common/input/input_param_traits.h"
   6
   7 #include "content/common/content_param_traits.h"
   8 #include "content/common/input/synthetic_pinch_gesture_params.h"
   9 #include "content/common/input/synthetic_smooth_scroll_gesture_params.h"
  10 #include "content/common/input/web_input_event_traits.h"
  11 #include "content/common/input_messages.h"
  12
  13 namespace IPC {
  14 namespace {
  15 template<typename GestureType>
  16 scoped_ptr<content::SyntheticGestureParams> ReadGestureParams(
  17     const Message* m,
  18     PickleIterator* iter)
  19 {
  20   scoped_ptr<GestureType> gesture_params(new GestureType);
  21   if (!ReadParam(m, iter, gesture_params.get()))
  22     return scoped_ptr<content::SyntheticGestureParams>();
  23
  24   return gesture_params.template PassAs<content::SyntheticGestureParams>();
  25 }
  26 }  // namespace
  27
  28 void ParamTraits<content::ScopedWebInputEvent>::Write(Message* m,
  29                                                       const param_type& p) {
  30   bool valid_web_event = !!p;
  31   WriteParam(m, valid_web_event);
  32   if (valid_web_event)
  33     WriteParam(m, static_cast<WebInputEventPointer>(p.get()));
  34 }
  35
  36 bool ParamTraits<content::ScopedWebInputEvent>::Read(const Message* m,
  37                                                      PickleIterator* iter,
  38                                                      param_type* p) {
  39   bool valid_web_event = false;
  40   WebInputEventPointer web_event_pointer = NULL;
  41   if (!ReadParam(m, iter, &valid_web_event) ||
  42       !valid_web_event ||
  43       !ReadParam(m, iter, &web_event_pointer) ||
  44       !web_event_pointer)
  45     return false;
  46
  47   (*p) = content::WebInputEventTraits::Clone(*web_event_pointer);
  48   return true;
  49 }
  50
  51 void ParamTraits<content::ScopedWebInputEvent>::Log(const param_type& p,
  52                                                     std::string* l) {
  53   LogParam(static_cast<WebInputEventPointer>(p.get()), l);
  54 }
  55
  56 void ParamTraits<content::SyntheticGesturePacket>::Write(Message* m,
  57                                                          const param_type& p) {
  58   DCHECK(p.gesture_params());
  59   WriteParam(m, p.gesture_params()->GetGestureType());
  60   switch (p.gesture_params()->GetGestureType()) {
  61     case content::SyntheticGestureParams::SMOOTH_SCROLL_GESTURE:
  62       WriteParam(m, *content::SyntheticSmoothScrollGestureParams::Cast(
  63           p.gesture_params()));
  64       break;
  65     case content::SyntheticGestureParams::PINCH_GESTURE:
  66       WriteParam(m, *content::SyntheticPinchGestureParams::Cast(
  67           p.gesture_params()));
  68       break;
  69     case content::SyntheticGestureParams::TAP_GESTURE:
  70       WriteParam(m, *content::SyntheticTapGestureParams::Cast(
  71           p.gesture_params()));
  72       break;
  73   }
  74 }
  75
  76 bool ParamTraits<content::SyntheticGesturePacket>::Read(const Message* m,
  77                                                         PickleIterator* iter,
  78                                                         param_type* p) {
  79   content::SyntheticGestureParams::GestureType gesture_type;
  80   if (!ReadParam(m, iter, &gesture_type))
  81     return false;
  82   scoped_ptr<content::SyntheticGestureParams> gesture_params;
  83   switch (gesture_type) {
  84     case content::SyntheticGestureParams::SMOOTH_SCROLL_GESTURE:
  85       gesture_params =
  86           ReadGestureParams<content::SyntheticSmoothScrollGestureParams>(m,
  87                                                                          iter);
  88       break;
  89     case content::SyntheticGestureParams::PINCH_GESTURE:
  90       gesture_params =
  91           ReadGestureParams<content::SyntheticPinchGestureParams>(m, iter);
  92       break;
  93     case content::SyntheticGestureParams::TAP_GESTURE:
  94       gesture_params =
  95           ReadGestureParams<content::SyntheticTapGestureParams>(m, iter);
  96       break;
  97     default:
  98       return false;
  99   }
 100
 101   p->set_gesture_params(gesture_params.Pass());
 102   return p->gesture_params() != NULL;
 103 }
 104
 105 void ParamTraits<content::SyntheticGesturePacket>::Log(const param_type& p,
 106                                                        std::string* l) {
 107   DCHECK(p.gesture_params());
 108   switch (p.gesture_params()->GetGestureType()) {
 109     case content::SyntheticGestureParams::SMOOTH_SCROLL_GESTURE:
 110       LogParam(
 111           *content::SyntheticSmoothScrollGestureParams::Cast(
 112               p.gesture_params()),
 113           l);
 114       break;
 115     case content::SyntheticGestureParams::PINCH_GESTURE:
 116       LogParam(
 117           *content::SyntheticPinchGestureParams::Cast(p.gesture_params()),
 118           l);
 119       break;
 120     case content::SyntheticGestureParams::TAP_GESTURE:
 121       LogParam(
 122           *content::SyntheticTapGestureParams::Cast(p.gesture_params()),
 123           l);
 124       break;
 125   }
 126 }
 127
 128 }  // namespace IPC