Add modifier flags to MotionEvent

content/browser/renderer_host/input/motion_event_android_unittest.cc

 // Copyright 2014 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 <android/input.h>
+
 #include "base/android/jni_android.h"
 #include "base/float_util.h"
 #include "content/browser/renderer_host/input/motion_event_android.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "ui/events/event_constants.h"
 
 using ui::MotionEvent;
 
 namespace content {
 namespace {
 const float kPixToDip = 0.5f;
 
-// Corresponds to ACTION_DOWN, see
-// developer.android.com/reference/android/view/MotionEvent.html#ACTION_DOWN.
-int kAndroidActionDown = 0;
+int kAndroidActionDown = AMOTION_EVENT_ACTION_DOWN;
+
+int kAndroidAltKeyDown = AMETA_ALT_ON;
 
 // Corresponds to TOOL_TYPE_FINGER, see
 // developer.android.com/reference/android/view/MotionEvent.html
 //     #TOOL_TYPE_FINGER.
 int kAndroidToolTypeFinger = 1;
 
 // Corresponds to BUTTON_PRIMARY, see
 // developer.android.com/reference/android/view/MotionEvent.html#BUTTON_PRIMARY.
 int kAndroidButtonPrimary = 1;
 
@@ skipping 41 matching lines @@
                            touch_major0,
                            touch_major1,
                            touch_minor0,
                            touch_minor1,
                            orientation0,
                            orientation1,
                            x0 + raw_offset,
                            y0 - raw_offset,
                            kAndroidToolTypeFinger,
                            kAndroidToolTypeFinger,
-                           kAndroidButtonPrimary);
+                           kAndroidButtonPrimary,
+                           kAndroidAltKeyDown);
 
   EXPECT_EQ(MotionEvent::ACTION_DOWN, event.GetAction());
   EXPECT_EQ(event_time, event.GetEventTime());
   EXPECT_EQ(x0 * kPixToDip, event.GetX(0));
   EXPECT_EQ(y0 * kPixToDip, event.GetY(0));
   EXPECT_EQ(x1 * kPixToDip, event.GetX(1));
   EXPECT_EQ(y1 * kPixToDip, event.GetY(1));
   EXPECT_FLOAT_EQ((x0 + raw_offset) * kPixToDip, event.GetRawX(0));
   EXPECT_FLOAT_EQ((y0 - raw_offset) * kPixToDip, event.GetRawY(0));
   EXPECT_FLOAT_EQ((x1 + raw_offset) * kPixToDip, event.GetRawX(1));
   EXPECT_FLOAT_EQ((y1 - raw_offset) * kPixToDip, event.GetRawY(1));
   EXPECT_EQ(touch_major0 * kPixToDip, event.GetTouchMajor(0));
   EXPECT_EQ(touch_major1 * kPixToDip, event.GetTouchMajor(1));
   EXPECT_EQ(touch_minor0 * kPixToDip, event.GetTouchMinor(0));
   EXPECT_EQ(touch_minor1 * kPixToDip, event.GetTouchMinor(1));
   EXPECT_EQ(orientation0, event.GetOrientation(0));
   EXPECT_EQ(0.f, event.GetOrientation(1));
   EXPECT_EQ(p0, event.GetPointerId(0));
   EXPECT_EQ(p1, event.GetPointerId(1));
   EXPECT_EQ(MotionEvent::TOOL_TYPE_FINGER, event.GetToolType(0));
   EXPECT_EQ(MotionEvent::TOOL_TYPE_FINGER, event.GetToolType(1));
   EXPECT_EQ(MotionEvent::BUTTON_PRIMARY, event.GetButtonState());
+  EXPECT_EQ(ui::EF_ALT_DOWN, event.GetFlags());
   EXPECT_EQ(static_cast<size_t>(pointer_count), event.GetPointerCount());
   EXPECT_EQ(static_cast<size_t>(history_size), event.GetHistorySize());
   EXPECT_EQ(action_index, event.GetActionIndex());
 }
 
 TEST(MotionEventAndroidTest, Clone) {
   int event_time_ms = 5;
   base::TimeTicks event_time =
       base::TimeTicks() + base::TimeDelta::FromMilliseconds(event_time_ms);
   float x = 13.7f;
@@ skipping 25 matching lines @@
                            touch_major,
                            0.f,
                            touch_minor,
                            0.f,
                            orientation,
                            0.f,
                            x,
                            y,
                            0,
                            0,
+                           0,
                            0);
 
   scoped_ptr<MotionEvent> clone = event.Clone();
   EXPECT_EQ(event, *clone);
 }
 
 TEST(MotionEventAndroidTest, Cancel) {
   int event_time_ms = 5;
   base::TimeTicks event_time =
       base::TimeTicks() + base::TimeDelta::FromMilliseconds(event_time_ms);
@@ skipping 22 matching lines @@
                            0.f,
                            0.f,
                            0.f,
                            0.f,
                            0.f,
                            0.f,
                            x,
                            y,
                            0,
                            0,
+                           0,
                            0);
 
   scoped_ptr<MotionEvent> cancel_event = event.Cancel();
   EXPECT_EQ(MotionEvent::ACTION_CANCEL, cancel_event->GetAction());
   EXPECT_EQ(event_time, cancel_event->GetEventTime());
   EXPECT_EQ(x * kPixToDip, cancel_event->GetX(0));
   EXPECT_EQ(y * kPixToDip, cancel_event->GetY(0));
   EXPECT_EQ(static_cast<size_t>(pointer_count),
             cancel_event->GetPointerCount());
   EXPECT_EQ(0U, cancel_event->GetHistorySize());
 }
 
 }  // namespace content