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_drag_gesture_params.h"
  10 #include "content/common/input/synthetic_smooth_scroll_gesture_params.h"
  11 #include "content/common/input/web_input_event_traits.h"
  12 #include "content/common/input_messages.h"
  13
  14 namespace IPC {
  15 namespace {
  16 template <typename GestureType>
  17 scoped_ptr<content::SyntheticGestureParams> ReadGestureParams(
  18     const Message* m,
  19     base::PickleIterator* iter) {
  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.Pass();
  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                                                      base::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::SMOOTH_DRAG_GESTURE:
  66       WriteParam(m, *content::SyntheticSmoothDragGestureParams::Cast(
  67                  p.gesture_params()));
  68       break;
  69     case content::SyntheticGestureParams::PINCH_GESTURE:
  70       WriteParam(m, *content::SyntheticPinchGestureParams::Cast(
  71           p.gesture_params()));
  72       break;
  73     case content::SyntheticGestureParams::TAP_GESTURE:
  74       WriteParam(m, *content::SyntheticTapGestureParams::Cast(
  75           p.gesture_params()));
  76       break;
  77   }
  78 }
  79
  80 bool ParamTraits<content::SyntheticGesturePacket>::Read(
  81     const Message* m,
  82     base::PickleIterator* iter,
  83     param_type* p) {
  84   content::SyntheticGestureParams::GestureType gesture_type;
  85   if (!ReadParam(m, iter, &gesture_type))
  86     return false;
  87   scoped_ptr<content::SyntheticGestureParams> gesture_params;
  88   switch (gesture_type) {
  89     case content::SyntheticGestureParams::SMOOTH_SCROLL_GESTURE:
  90       gesture_params =
  91           ReadGestureParams<content::SyntheticSmoothScrollGestureParams>(m,
  92                                                                          iter);
  93       break;
  94     case content::SyntheticGestureParams::SMOOTH_DRAG_GESTURE:
  95       gesture_params =
  96           ReadGestureParams<content::SyntheticSmoothDragGestureParams>(m, iter);
  97       break;
  98     case content::SyntheticGestureParams::PINCH_GESTURE:
  99       gesture_params =
 100           ReadGestureParams<content::SyntheticPinchGestureParams>(m, iter);
 101       break;
 102     case content::SyntheticGestureParams::TAP_GESTURE:
 103       gesture_params =
 104           ReadGestureParams<content::SyntheticTapGestureParams>(m, iter);
 105       break;
 106     default:
 107       return false;
 108   }
 109
 110   p->set_gesture_params(gesture_params.Pass());
 111   return p->gesture_params() != NULL;
 112 }
 113
 114 void ParamTraits<content::SyntheticGesturePacket>::Log(const param_type& p,
 115                                                        std::string* l) {
 116   DCHECK(p.gesture_params());
 117   switch (p.gesture_params()->GetGestureType()) {
 118     case content::SyntheticGestureParams::SMOOTH_SCROLL_GESTURE:
 119       LogParam(
 120           *content::SyntheticSmoothScrollGestureParams::Cast(
 121               p.gesture_params()),
 122           l);
 123       break;
 124     case content::SyntheticGestureParams::SMOOTH_DRAG_GESTURE:
 125       LogParam(
 126           *content::SyntheticSmoothDragGestureParams::Cast(p.gesture_params()),
 127           l);
 128       break;
 129     case content::SyntheticGestureParams::PINCH_GESTURE:
 130       LogParam(
 131           *content::SyntheticPinchGestureParams::Cast(p.gesture_params()),
 132           l);
 133       break;
 134     case content::SyntheticGestureParams::TAP_GESTURE:
 135       LogParam(
 136           *content::SyntheticTapGestureParams::Cast(p.gesture_params()),
 137           l);
 138       break;
 139   }
 140 }
 141
 142 }  // namespace IPC