BASELINE: Update chromium to 44.0.2403.47

Change-Id: Ie056fedba95cf5e5c76b30c4b2c80fca4764aa2f
Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@theqtcompany.com>

20 files changed, 365 insertions, 226 deletions

diff --git a/chromium/mojo/converters/geometry/BUILD.gn b/chromium/mojo/converters/geometry/BUILD.gn
index 2d0a1e00ec1..58b46e7ecd1 100644
--- a/chromium/mojo/converters/geometry/BUILD.gn
+++ b/chromium/mojo/converters/geometry/BUILD.gn
@@ -2,24 +2,21 @@
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-# GYP version: mojo/mojo_converters.gypi:mojo_geometry_lib
+# This target does NOT depend on skia. One can depend on this target to avoid
+# picking up a dependency on skia.
 component("geometry") {
   output_name = "mojo_geometry_lib"
 
   public_deps = [
-    "//ui/gfx",
+    "//ui/gfx/geometry",
   ]
   deps = [
-    "//skia",
-    "//ui/gfx/geometry",
     "//mojo/environment:chromium",
-    "//mojo/public/c/system:for_component",
-    "//mojo/services/public/interfaces/geometry",
+    "//third_party/mojo/src/mojo/public/c/system:for_component",
+    "//ui/mojo/geometry:interfaces",
   ]
 
-  defines = [
-    "MOJO_GEOMETRY_IMPLEMENTATION",
-  ]
+  defines = [ "MOJO_GEOMETRY_IMPLEMENTATION" ]
 
   sources = [
     "geometry_type_converters.cc",
diff --git a/chromium/mojo/converters/geometry/DEPS b/chromium/mojo/converters/geometry/DEPS
index 3e038102d0a..3985ac331a4 100644
--- a/chromium/mojo/converters/geometry/DEPS
+++ b/chromium/mojo/converters/geometry/DEPS
@@ -1,4 +1,4 @@
 include_rules = [
   "+ui/gfx/geometry",
-  "+ui/gfx/transform.h",
+  "+ui/mojo/geometry",
 ]
diff --git a/chromium/mojo/converters/geometry/geometry_type_converters.cc b/chromium/mojo/converters/geometry/geometry_type_converters.cc
index 38308794d95..fb17e0321a5 100644
--- a/chromium/mojo/converters/geometry/geometry_type_converters.cc
+++ b/chromium/mojo/converters/geometry/geometry_type_converters.cc
@@ -88,25 +88,18 @@ gfx::RectF TypeConverter<gfx::RectF, RectFPtr>::Convert(const RectFPtr& input) {
 }
 
 // static
-TransformPtr TypeConverter<TransformPtr, gfx::Transform>::Convert(
-    const gfx::Transform& input) {
-  std::vector<float> storage(16);
-  input.matrix().asRowMajorf(&storage[0]);
-  mojo::Array<float> matrix;
-  matrix.Swap(&storage);
-  TransformPtr transform(Transform::New());
-  transform->matrix = matrix.Pass();
-  return transform.Pass();
+Rect TypeConverter<Rect, gfx::Rect>::Convert(const gfx::Rect& input) {
+  Rect rect;
+  rect.x = input.x();
+  rect.y = input.y();
+  rect.width = input.width();
+  rect.height = input.height();
+  return rect;
 }
 
 // static
-gfx::Transform TypeConverter<gfx::Transform, TransformPtr>::Convert(
-    const TransformPtr& input) {
-  if (input.is_null())
-    return gfx::Transform();
-  gfx::Transform transform(gfx::Transform::kSkipInitialization);
-  transform.matrix().setRowMajorf(&input->matrix.storage()[0]);
-  return transform;
+gfx::Rect TypeConverter<gfx::Rect, Rect>::Convert(const Rect& input) {
+  return gfx::Rect(input.x, input.y, input.width, input.height);
 }
 
 }  // namespace mojo
diff --git a/chromium/mojo/converters/geometry/geometry_type_converters.h b/chromium/mojo/converters/geometry/geometry_type_converters.h
index ee9ea72c833..f19939b752c 100644
--- a/chromium/mojo/converters/geometry/geometry_type_converters.h
+++ b/chromium/mojo/converters/geometry/geometry_type_converters.h
@@ -6,12 +6,11 @@
 #define MOJO_CONVERTERS_GEOMETRY_GEOMETRY_TYPE_CONVERTERS_H_
 
 #include "mojo/converters/geometry/mojo_geometry_export.h"
-#include "mojo/services/public/interfaces/geometry/geometry.mojom.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/geometry/point_f.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/size.h"
-#include "ui/gfx/transform.h"
+#include "ui/mojo/geometry/geometry.mojom.h"
 
 namespace mojo {
 
@@ -61,12 +60,12 @@ struct MOJO_GEOMETRY_EXPORT TypeConverter<gfx::RectF, RectFPtr> {
 };
 
 template <>
-struct MOJO_GEOMETRY_EXPORT TypeConverter<TransformPtr, gfx::Transform> {
-  static TransformPtr Convert(const gfx::Transform& input);
+struct MOJO_GEOMETRY_EXPORT TypeConverter<Rect, gfx::Rect> {
+  static Rect Convert(const gfx::Rect& input);
 };
 template <>
-struct MOJO_GEOMETRY_EXPORT TypeConverter<gfx::Transform, TransformPtr> {
-  static gfx::Transform Convert(const TransformPtr& input);
+struct MOJO_GEOMETRY_EXPORT TypeConverter<gfx::Rect, Rect> {
+  static gfx::Rect Convert(const Rect& input);
 };
 
 }  // namespace mojo
diff --git a/chromium/mojo/converters/input_events/BUILD.gn b/chromium/mojo/converters/input_events/BUILD.gn
index 94df786fecd..e3790d53729 100644
--- a/chromium/mojo/converters/input_events/BUILD.gn
+++ b/chromium/mojo/converters/input_events/BUILD.gn
@@ -11,18 +11,16 @@ component("input_events") {
     "mojo_input_events_export.h",
   ]
 
-  defines = [
-    "MOJO_INPUT_EVENTS_IMPLEMENTATION",
-  ]
+  defines = [ "MOJO_INPUT_EVENTS_IMPLEMENTATION" ]
 
   deps = [
     "//base",
-    "//ui/events",
-    "//ui/gfx/geometry",
     "//mojo/converters/geometry",
     "//mojo/environment:chromium",
-    "//mojo/public/c/system:for_component",
-    "//mojo/services/public/interfaces/input_events",
-    "//mojo/services/public/interfaces/geometry",
+    "//third_party/mojo/src/mojo/public/c/system:for_component",
+    "//ui/events",
+    "//ui/gfx/geometry",
+    "//ui/mojo/events:interfaces",
+    "//ui/mojo/geometry:interfaces",
   ]
 }
diff --git a/chromium/mojo/converters/input_events/DEPS b/chromium/mojo/converters/input_events/DEPS
index fe1d98e366d..81a00b0a8ae 100644
--- a/chromium/mojo/converters/input_events/DEPS
+++ b/chromium/mojo/converters/input_events/DEPS
@@ -1,3 +1,4 @@
 include_rules = [
   "+ui/events",
+  "+ui/mojo/events",
 ]
diff --git a/chromium/mojo/converters/input_events/input_event_names.h b/chromium/mojo/converters/input_events/input_event_names.h
deleted file mode 100644
index 3fd6ef63a2f..00000000000
--- a/chromium/mojo/converters/input_events/input_event_names.h
+++ /dev/null
@@ -1,46 +0,0 @@
-// 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.
-
-MOJO_INPUT_EVENT_NAME(UNKNOWN);
-MOJO_INPUT_EVENT_NAME(MOUSE_PRESSED);
-MOJO_INPUT_EVENT_NAME(MOUSE_DRAGGED);
-MOJO_INPUT_EVENT_NAME(MOUSE_RELEASED);
-MOJO_INPUT_EVENT_NAME(MOUSE_MOVED);
-MOJO_INPUT_EVENT_NAME(MOUSE_ENTERED);
-MOJO_INPUT_EVENT_NAME(MOUSE_EXITED);
-MOJO_INPUT_EVENT_NAME(KEY_PRESSED);
-MOJO_INPUT_EVENT_NAME(KEY_RELEASED);
-MOJO_INPUT_EVENT_NAME(MOUSEWHEEL);
-MOJO_INPUT_EVENT_NAME(MOUSE_CAPTURE_CHANGED);
-MOJO_INPUT_EVENT_NAME(TOUCH_RELEASED);
-MOJO_INPUT_EVENT_NAME(TOUCH_PRESSED);
-MOJO_INPUT_EVENT_NAME(TOUCH_MOVED);
-MOJO_INPUT_EVENT_NAME(TOUCH_CANCELLED);
-MOJO_INPUT_EVENT_NAME(DROP_TARGET_EVENT);
-MOJO_INPUT_EVENT_NAME(TRANSLATED_KEY_PRESS);
-MOJO_INPUT_EVENT_NAME(TRANSLATED_KEY_RELEASE);
-MOJO_INPUT_EVENT_NAME(GESTURE_SCROLL_BEGIN);
-MOJO_INPUT_EVENT_NAME(GESTURE_SCROLL_END);
-MOJO_INPUT_EVENT_NAME(GESTURE_SCROLL_UPDATE);
-MOJO_INPUT_EVENT_NAME(GESTURE_TAP);
-MOJO_INPUT_EVENT_NAME(GESTURE_TAP_DOWN);
-MOJO_INPUT_EVENT_NAME(GESTURE_TAP_CANCEL);
-MOJO_INPUT_EVENT_NAME(GESTURE_TAP_UNCONFIRMED);
-MOJO_INPUT_EVENT_NAME(GESTURE_DOUBLE_TAP);
-MOJO_INPUT_EVENT_NAME(GESTURE_BEGIN);
-MOJO_INPUT_EVENT_NAME(GESTURE_END);
-MOJO_INPUT_EVENT_NAME(GESTURE_TWO_FINGER_TAP);
-MOJO_INPUT_EVENT_NAME(GESTURE_PINCH_BEGIN);
-MOJO_INPUT_EVENT_NAME(GESTURE_PINCH_END);
-MOJO_INPUT_EVENT_NAME(GESTURE_PINCH_UPDATE);
-MOJO_INPUT_EVENT_NAME(GESTURE_LONG_PRESS);
-MOJO_INPUT_EVENT_NAME(GESTURE_LONG_TAP);
-MOJO_INPUT_EVENT_NAME(GESTURE_SWIPE);
-MOJO_INPUT_EVENT_NAME(GESTURE_SHOW_PRESS);
-MOJO_INPUT_EVENT_NAME(GESTURE_WIN8_EDGE_SWIPE);
-MOJO_INPUT_EVENT_NAME(SCROLL);
-MOJO_INPUT_EVENT_NAME(SCROLL_FLING_START);
-MOJO_INPUT_EVENT_NAME(SCROLL_FLING_CANCEL);
-MOJO_INPUT_EVENT_NAME(CANCEL_MODE);
-MOJO_INPUT_EVENT_NAME(UMA_DATA);
diff --git a/chromium/mojo/converters/input_events/input_events_type_converters.cc b/chromium/mojo/converters/input_events/input_events_type_converters.cc
index 58ee75aa2a8..88b35fe6a3b 100644
--- a/chromium/mojo/converters/input_events/input_events_type_converters.cc
+++ b/chromium/mojo/converters/input_events/input_events_type_converters.cc
@@ -11,11 +11,75 @@
 
 #include "mojo/converters/geometry/geometry_type_converters.h"
 #include "mojo/converters/input_events/mojo_extended_key_event_data.h"
-#include "mojo/services/public/interfaces/input_events/input_events.mojom.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/keycodes/keyboard_codes.h"
+#include "ui/mojo/events/input_events.mojom.h"
 
 namespace mojo {
+namespace {
+
+ui::EventType MojoMouseEventTypeToUIEvent(const EventPtr& event) {
+  DCHECK(!event->pointer_data.is_null());
+  DCHECK_EQ(POINTER_KIND_MOUSE, event->pointer_data->kind);
+  switch (event->action) {
+    case EVENT_TYPE_POINTER_DOWN:
+      return ui::ET_MOUSE_PRESSED;
+
+    case EVENT_TYPE_POINTER_UP:
+      return ui::ET_MOUSE_RELEASED;
+
+    case EVENT_TYPE_POINTER_MOVE:
+      DCHECK(event->pointer_data);
+      if (event->pointer_data->horizontal_wheel != 0 ||
+          event->pointer_data->vertical_wheel != 0) {
+        return ui::ET_MOUSEWHEEL;
+      }
+      if (event->flags &
+          (EVENT_FLAGS_LEFT_MOUSE_BUTTON | EVENT_FLAGS_MIDDLE_MOUSE_BUTTON |
+           EVENT_FLAGS_RIGHT_MOUSE_BUTTON)) {
+        return ui::ET_MOUSE_DRAGGED;
+      }
+      return ui::ET_MOUSE_MOVED;
+
+    default:
+      NOTREACHED();
+  }
+
+  return ui::ET_MOUSE_RELEASED;
+}
+
+ui::EventType MojoTouchEventTypeToUIEvent(const EventPtr& event) {
+  DCHECK(!event->pointer_data.is_null());
+  DCHECK_EQ(POINTER_KIND_TOUCH, event->pointer_data->kind);
+  switch (event->action) {
+    case EVENT_TYPE_POINTER_DOWN:
+      return ui::ET_TOUCH_PRESSED;
+
+    case EVENT_TYPE_POINTER_UP:
+      return ui::ET_TOUCH_RELEASED;
+
+    case EVENT_TYPE_POINTER_MOVE:
+      return ui::ET_TOUCH_MOVED;
+
+    case EVENT_TYPE_POINTER_CANCEL:
+      return ui::ET_TOUCH_CANCELLED;
+
+    default:
+      NOTREACHED();
+  }
+
+  return ui::ET_TOUCH_CANCELLED;
+}
+
+void SetPointerDataLocationFromEvent(const ui::LocatedEvent& located_event,
+                                     PointerData* pointer_data) {
+  pointer_data->x = located_event.location_f().x();
+  pointer_data->y = located_event.location_f().y();
+  pointer_data->screen_x = located_event.root_location_f().x();
+  pointer_data->screen_y = located_event.root_location_f().y();
+}
+
+}  // namespace
 
 COMPILE_ASSERT(static_cast<int32>(EVENT_FLAGS_NONE) ==
                static_cast<int32>(ui::EF_NONE),
@@ -60,62 +124,80 @@ COMPILE_ASSERT(static_cast<int32>(EVENT_FLAGS_MOD3_DOWN) ==
 
 // static
 EventType TypeConverter<EventType, ui::EventType>::Convert(ui::EventType type) {
-#define MOJO_INPUT_EVENT_NAME(name) case ui::ET_##name: return EVENT_TYPE_##name
-
   switch (type) {
-#include "mojo/converters/input_events/input_event_names.h"
-    case ui::ET_LAST:
-      NOTREACHED();
-      break;
-  }
+    case ui::ET_MOUSE_PRESSED:
+    case ui::ET_TOUCH_PRESSED:
+      return EVENT_TYPE_POINTER_DOWN;
 
-#undef MOJO_INPUT_EVENT_NAME
+    case ui::ET_MOUSE_DRAGGED:
+    case ui::ET_MOUSE_MOVED:
+    case ui::ET_MOUSE_ENTERED:
+    case ui::ET_MOUSE_EXITED:
+    case ui::ET_TOUCH_MOVED:
+    case ui::ET_MOUSEWHEEL:
+      return EVENT_TYPE_POINTER_MOVE;
 
-  NOTREACHED();
-  return EVENT_TYPE_UNKNOWN;
-}
+    case ui::ET_MOUSE_RELEASED:
+    case ui::ET_TOUCH_RELEASED:
+      return EVENT_TYPE_POINTER_UP;
 
-// static
-ui::EventType TypeConverter<ui::EventType, EventType>::Convert(EventType type) {
-#define MOJO_INPUT_EVENT_NAME(name) case EVENT_TYPE_##name: return ui::ET_##name
+    case ui::ET_TOUCH_CANCELLED:
+      return EVENT_TYPE_POINTER_CANCEL;
 
-  switch (type) {
-#include "mojo/converters/input_events/input_event_names.h"
-  }
+    case ui::ET_KEY_PRESSED:
+      return EVENT_TYPE_KEY_PRESSED;
 
-#undef MOJO_INPUT_EVENT_NAME
+    case ui::ET_KEY_RELEASED:
+      return EVENT_TYPE_KEY_RELEASED;
 
-  NOTREACHED();
-  return ui::ET_UNKNOWN;
+    default:
+      break;
+  }
+  return EVENT_TYPE_UNKNOWN;
 }
 
-// static
 EventPtr TypeConverter<EventPtr, ui::Event>::Convert(const ui::Event& input) {
-  EventPtr event(Event::New());
-  event->action = ConvertTo<EventType>(input.type());
+  const EventType type = ConvertTo<EventType>(input.type());
+  if (type == EVENT_TYPE_UNKNOWN)
+    return nullptr;
+
+  EventPtr event = Event::New();
+  event->action = type;
   event->flags = EventFlags(input.flags());
   event->time_stamp = input.time_stamp().ToInternalValue();
 
-  if (input.IsMouseEvent() || input.IsTouchEvent()) {
+  PointerData pointer_data;
+  if (input.IsMouseEvent()) {
     const ui::LocatedEvent* located_event =
         static_cast<const ui::LocatedEvent*>(&input);
-
-    LocationDataPtr location_data(LocationData::New());
-    location_data->in_view_location = Point::From(located_event->location());
-    if (input.HasNativeEvent()) {
-      location_data->screen_location =
-          Point::From(ui::EventSystemLocationFromNative(input.native_event()));
+    PointerDataPtr pointer_data(PointerData::New());
+    // TODO(sky): come up with a better way to handle this.
+    pointer_data->pointer_id = std::numeric_limits<int32>::max();
+    pointer_data->kind = POINTER_KIND_MOUSE;
+    SetPointerDataLocationFromEvent(*located_event, pointer_data.get());
+    if (input.IsMouseWheelEvent()) {
+      const ui::MouseWheelEvent* wheel_event =
+          static_cast<const ui::MouseWheelEvent*>(&input);
+      // This conversion assumes we're using the mojo meaning of these values:
+      // [-1 1].
+      pointer_data->horizontal_wheel =
+          static_cast<float>(wheel_event->x_offset()) / 100.0f;
+      pointer_data->vertical_wheel =
+          static_cast<float>(wheel_event->y_offset()) / 100.0f;
     }
-
-    event->location_data = location_data.Pass();
-  }
-
-  if (input.IsTouchEvent()) {
+    event->pointer_data = pointer_data.Pass();
+  } else if (input.IsTouchEvent()) {
     const ui::TouchEvent* touch_event =
         static_cast<const ui::TouchEvent*>(&input);
-    TouchDataPtr touch_data(TouchData::New());
-    touch_data->pointer_id = touch_event->touch_id();
-    event->touch_data = touch_data.Pass();
+    PointerDataPtr pointer_data(PointerData::New());
+    pointer_data->pointer_id = touch_event->touch_id();
+    pointer_data->kind = POINTER_KIND_TOUCH;
+    SetPointerDataLocationFromEvent(*touch_event, pointer_data.get());
+    pointer_data->radius_major = touch_event->radius_x();
+    pointer_data->radius_minor = touch_event->radius_y();
+    pointer_data->pressure = touch_event->force();
+    pointer_data->orientation = touch_event->rotation_angle();
+    event->pointer_data = pointer_data.Pass();
   } else if (input.IsKeyEvent()) {
     const ui::KeyEvent* key_event = static_cast<const ui::KeyEvent*>(&input);
     KeyDataPtr key_data(KeyData::New());
@@ -138,15 +220,7 @@ EventPtr TypeConverter<EventPtr, ui::Event>::Convert(const ui::Event& input) {
       key_data->text = key_event->GetText();
       key_data->unmodified_text = key_event->GetUnmodifiedText();
     }
-
     event->key_data = key_data.Pass();
-  } else if (input.IsMouseWheelEvent()) {
-    const ui::MouseWheelEvent* wheel_event =
-        static_cast<const ui::MouseWheelEvent*>(&input);
-    MouseWheelDataPtr wheel_data(MouseWheelData::New());
-    wheel_data->x_offset = wheel_event->x_offset();
-    wheel_data->y_offset = wheel_event->y_offset();
-    event->wheel_data = wheel_data.Pass();
   }
   return event.Pass();
 }
@@ -160,18 +234,17 @@ EventPtr TypeConverter<EventPtr, ui::KeyEvent>::Convert(
 // static
 scoped_ptr<ui::Event> TypeConverter<scoped_ptr<ui::Event>, EventPtr>::Convert(
     const EventPtr& input) {
-  scoped_ptr<ui::Event> ui_event;
-  ui::EventType ui_event_type = ConvertTo<ui::EventType>(input->action);
-
-  gfx::Point location;
-  if (!input->location_data.is_null() &&
-      !input->location_data->in_view_location.is_null()) {
-    location = input->location_data->in_view_location.To<gfx::Point>();
+  gfx::PointF location;
+  gfx::PointF screen_location;
+  if (!input->pointer_data.is_null()) {
+    location.SetPoint(input->pointer_data->x, input->pointer_data->y);
+    screen_location.SetPoint(input->pointer_data->screen_x,
+                             input->pointer_data->screen_y);
   }
 
   switch (input->action) {
-    case ui::ET_KEY_PRESSED:
-    case ui::ET_KEY_RELEASED: {
+    case EVENT_TYPE_KEY_PRESSED:
+    case EVENT_TYPE_KEY_RELEASED: {
       scoped_ptr<ui::KeyEvent> key_event;
       if (input->key_data->is_char) {
         key_event.reset(new ui::KeyEvent(
@@ -181,9 +254,10 @@ scoped_ptr<ui::Event> TypeConverter<scoped_ptr<ui::Event>, EventPtr>::Convert(
             input->flags));
       } else {
         key_event.reset(new ui::KeyEvent(
-            ui_event_type,
-            static_cast<ui::KeyboardCode>(
-                input->key_data->key_code),
+            input->action == EVENT_TYPE_KEY_PRESSED ? ui::ET_KEY_PRESSED
+                                                    : ui::ET_KEY_RELEASED,
+
+            static_cast<ui::KeyboardCode>(input->key_data->key_code),
             input->flags));
       }
       key_event->SetExtendedKeyEventData(scoped_ptr<ui::ExtendedKeyEventData>(
@@ -192,54 +266,43 @@ scoped_ptr<ui::Event> TypeConverter<scoped_ptr<ui::Event>, EventPtr>::Convert(
               input->key_data->text,
               input->key_data->unmodified_text)));
       key_event->set_platform_keycode(input->key_data->native_key_code);
-      ui_event = key_event.Pass();
-      break;
-    }
-    case EVENT_TYPE_MOUSE_PRESSED:
-    case EVENT_TYPE_MOUSE_DRAGGED:
-    case EVENT_TYPE_MOUSE_RELEASED:
-    case EVENT_TYPE_MOUSE_MOVED:
-    case EVENT_TYPE_MOUSE_ENTERED:
-    case EVENT_TYPE_MOUSE_EXITED: {
-      // TODO: last flags isn't right. Need to send changed_flags.
-      ui_event.reset(new ui::MouseEvent(
-                         ui_event_type,
-                         location,
-                         location,
-                         ui::EventFlags(input->flags),
-                         ui::EventFlags(input->flags)));
-      break;
+      return key_event.Pass();
     }
-    case EVENT_TYPE_MOUSEWHEEL: {
-      const gfx::Vector2d offset(input->wheel_data->x_offset,
-                                 input->wheel_data->y_offset);
-      ui_event.reset(new ui::MouseWheelEvent(offset,
-                                             location,
-                                             location,
-                                             ui::EventFlags(input->flags),
-                                             ui::EventFlags(input->flags)));
-      break;
-    }
-    case EVENT_TYPE_TOUCH_MOVED:
-    case EVENT_TYPE_TOUCH_PRESSED:
-    case EVENT_TYPE_TOUCH_CANCELLED:
-    case EVENT_TYPE_TOUCH_RELEASED: {
-      ui_event.reset(new ui::TouchEvent(
-                         ui_event_type,
-                         location,
-                         ui::EventFlags(input->flags),
-                         input->touch_data->pointer_id,
-                         base::TimeDelta::FromInternalValue(input->time_stamp),
-                         0.f, 0.f, 0.f, 0.f));
-      break;
+    case EVENT_TYPE_POINTER_DOWN:
+    case EVENT_TYPE_POINTER_UP:
+    case EVENT_TYPE_POINTER_MOVE:
+    case EVENT_TYPE_POINTER_CANCEL: {
+      if (input->pointer_data->kind == POINTER_KIND_MOUSE) {
+        // TODO: last flags isn't right. Need to send changed_flags.
+        scoped_ptr<ui::MouseEvent> event(new ui::MouseEvent(
+            MojoMouseEventTypeToUIEvent(input), location, screen_location,
+            ui::EventTimeForNow(), ui::EventFlags(input->flags),
+            ui::EventFlags(input->flags)));
+        if (event->IsMouseWheelEvent()) {
+          // This conversion assumes we're using the mojo meaning of these
+          // values: [-1 1].
+          scoped_ptr<ui::MouseEvent> wheel_event(new ui::MouseWheelEvent(
+              *event,
+              static_cast<int>(input->pointer_data->horizontal_wheel * 100),
+              static_cast<int>(input->pointer_data->vertical_wheel * 100)));
+          event = wheel_event.Pass();
+        }
+        return event.Pass();
+      }
+      scoped_ptr<ui::TouchEvent> touch_event(new ui::TouchEvent(
+          MojoTouchEventTypeToUIEvent(input), location,
+          ui::EventFlags(input->flags), input->pointer_data->pointer_id,
+          base::TimeDelta::FromInternalValue(input->time_stamp),
+          input->pointer_data->radius_major, input->pointer_data->radius_minor,
+          input->pointer_data->orientation, input->pointer_data->pressure));
+      touch_event->set_root_location(screen_location);
+      return touch_event.Pass();
     }
     default:
-      // TODO: support other types.
-      // NOTIMPLEMENTED();
-      ;
+      NOTIMPLEMENTED();
   }
   // TODO: need to support time_stamp.
-  return ui_event.Pass();
+  return nullptr;
 }
 
 }  // namespace mojo
diff --git a/chromium/mojo/converters/input_events/input_events_type_converters.h b/chromium/mojo/converters/input_events/input_events_type_converters.h
index 0577630a827..0a2e15313c9 100644
--- a/chromium/mojo/converters/input_events/input_events_type_converters.h
+++ b/chromium/mojo/converters/input_events/input_events_type_converters.h
@@ -7,22 +7,19 @@
 
 #include "base/memory/scoped_ptr.h"
 #include "mojo/converters/input_events/mojo_input_events_export.h"
-#include "mojo/services/public/interfaces/input_events/input_events.mojom.h"
 #include "ui/events/event.h"
+#include "ui/mojo/events/input_events.mojom.h"
 
 namespace mojo {
 
+// NOTE: the mojo input events do not necessarily provide a 1-1 mapping with
+// ui::Event types. Be careful in using them!
 template <>
 struct MOJO_INPUT_EVENTS_EXPORT TypeConverter<EventType, ui::EventType> {
   static EventType Convert(ui::EventType type);
 };
 
 template <>
-struct MOJO_INPUT_EVENTS_EXPORT TypeConverter<ui::EventType, EventType> {
-  static ui::EventType Convert(EventType type);
-};
-
-template <>
 struct MOJO_INPUT_EVENTS_EXPORT TypeConverter<EventPtr, ui::Event> {
   static EventPtr Convert(const ui::Event& input);
 };
@@ -33,6 +30,11 @@ struct MOJO_INPUT_EVENTS_EXPORT TypeConverter<EventPtr, ui::KeyEvent> {
 };
 
 template <>
+struct MOJO_INPUT_EVENTS_EXPORT TypeConverter<EventPtr, ui::GestureEvent> {
+  static EventPtr Convert(const ui::GestureEvent& input);
+};
+
+template <>
 struct MOJO_INPUT_EVENTS_EXPORT TypeConverter<scoped_ptr<ui::Event>, EventPtr> {
   static scoped_ptr<ui::Event> Convert(const EventPtr& input);
 };
diff --git a/chromium/mojo/converters/surfaces/BUILD.gn b/chromium/mojo/converters/surfaces/BUILD.gn
index ee2d2bbc871..48f055d88c5 100644
--- a/chromium/mojo/converters/surfaces/BUILD.gn
+++ b/chromium/mojo/converters/surfaces/BUILD.gn
@@ -18,6 +18,7 @@ component("surfaces") {
 
   public_deps = [
     "//mojo/converters/geometry",
+    "//mojo/converters/transform",
     "//ui/gfx",
   ]
 
@@ -25,12 +26,12 @@ component("surfaces") {
     "//base",
     "//cc",
     "//cc/surfaces",
+    "//components/surfaces/public/interfaces:surface_id",
+    "//components/surfaces/public/interfaces",
     "//gpu",
     "//ui/gfx/geometry",
     "//mojo/environment:chromium",
-    "//mojo/public/c/system:for_component",
-    "//mojo/services/public/interfaces/surfaces:surface_id",
-    "//mojo/services/public/interfaces/surfaces",
     "//skia",
+    "//third_party/mojo/src/mojo/public/c/system:for_component",
   ]
 }
diff --git a/chromium/mojo/converters/surfaces/DEPS b/chromium/mojo/converters/surfaces/DEPS
index bce2d34ae9a..c2d22dd3069 100644
--- a/chromium/mojo/converters/surfaces/DEPS
+++ b/chromium/mojo/converters/surfaces/DEPS
@@ -3,6 +3,7 @@ include_rules = [
   "+cc/quads",
   "+cc/resources",
   "+cc/surfaces",
+  "+components/surfaces",
   "+gpu/command_buffer/common/mailbox.h",
   "+gpu/command_buffer/common/mailbox_holder.h",
   "+third_party/skia/include",
diff --git a/chromium/mojo/converters/surfaces/surfaces_type_converters.cc b/chromium/mojo/converters/surfaces/surfaces_type_converters.cc
index a8e5911ccd0..0c27f783612 100644
--- a/chromium/mojo/converters/surfaces/surfaces_type_converters.cc
+++ b/chromium/mojo/converters/surfaces/surfaces_type_converters.cc
@@ -16,7 +16,9 @@
 #include "cc/quads/texture_draw_quad.h"
 #include "cc/quads/tile_draw_quad.h"
 #include "cc/quads/yuv_video_draw_quad.h"
+#include "cc/surfaces/surface_id_allocator.h"
 #include "mojo/converters/geometry/geometry_type_converters.h"
+#include "mojo/converters/transform/transform_type_converters.h"
 
 namespace mojo {
 
@@ -41,10 +43,8 @@ COMPILE_ASSERT(
     cc::YUVVideoDrawQuad::REC_601 ==
         static_cast<cc::YUVVideoDrawQuad::ColorSpace>(YUV_COLOR_SPACE_REC_601),
     rec_601_enum_matches);
-COMPILE_ASSERT(cc::YUVVideoDrawQuad::REC_601_JPEG ==
-                   static_cast<cc::YUVVideoDrawQuad::ColorSpace>(
-                       YUV_COLOR_SPACE_REC_601_JPEG),
-               rec_601_jpeg_enum_matches);
+// TODO(jamesr): Add REC_709 and JPEG to the YUVColorSpace enum upstream in
+// mojo.
 
 namespace {
 
@@ -140,7 +140,8 @@ bool ConvertDrawQuad(const QuadPtr& input,
           texture_quad_state->uv_bottom_right.To<gfx::PointF>(),
           texture_quad_state->background_color.To<SkColor>(),
           &texture_quad_state->vertex_opacity.storage()[0],
-          texture_quad_state->flipped);
+          texture_quad_state->y_flipped,
+          texture_quad_state->nearest_neighbor);
       break;
     }
     case MATERIAL_TILED_CONTENT: {
@@ -157,7 +158,8 @@ bool ConvertDrawQuad(const QuadPtr& input,
                         tile_state->resource_id,
                         tile_state->tex_coord_rect.To<gfx::RectF>(),
                         tile_state->texture_size.To<gfx::Size>(),
-                        tile_state->swizzle_contents);
+                        tile_state->swizzle_contents,
+                        tile_state->nearest_neighbor);
       break;
     }
     case MATERIAL_YUV_VIDEO_CONTENT: {
@@ -166,18 +168,17 @@ bool ConvertDrawQuad(const QuadPtr& input,
         return false;
       cc::YUVVideoDrawQuad* yuv_quad =
           render_pass->CreateAndAppendDrawQuad<cc::YUVVideoDrawQuad>();
-      yuv_quad->SetAll(sqs,
-                       input->rect.To<gfx::Rect>(),
-                       input->opaque_rect.To<gfx::Rect>(),
-                       input->visible_rect.To<gfx::Rect>(),
-                       input->needs_blending,
-                       yuv_state->tex_coord_rect.To<gfx::RectF>(),
-                       yuv_state->y_plane_resource_id,
-                       yuv_state->u_plane_resource_id,
-                       yuv_state->v_plane_resource_id,
-                       yuv_state->a_plane_resource_id,
-                       static_cast<cc::YUVVideoDrawQuad::ColorSpace>(
-                           yuv_state->color_space));
+      yuv_quad->SetAll(
+          sqs, input->rect.To<gfx::Rect>(), input->opaque_rect.To<gfx::Rect>(),
+          input->visible_rect.To<gfx::Rect>(), input->needs_blending,
+          gfx::RectF(),  // TODO(sky): ya tex coord rect
+          gfx::RectF(),  // TODO(sky): uv tex coord rect
+          gfx::Size(),   // TODO(sky): ya texture size
+          gfx::Size(),   // TODO(sky): uv texture size
+          yuv_state->y_plane_resource_id, yuv_state->u_plane_resource_id,
+          yuv_state->v_plane_resource_id, yuv_state->a_plane_resource_id,
+          static_cast<cc::YUVVideoDrawQuad::ColorSpace>(
+              yuv_state->color_space));
       break;
     }
     default:
@@ -193,14 +194,18 @@ bool ConvertDrawQuad(const QuadPtr& input,
 SurfaceIdPtr TypeConverter<SurfaceIdPtr, cc::SurfaceId>::Convert(
     const cc::SurfaceId& input) {
   SurfaceIdPtr id(SurfaceId::New());
-  id->id = input.id;
+  id->local = static_cast<uint32_t>(input.id);
+  id->id_namespace = cc::SurfaceIdAllocator::NamespaceForId(input);
   return id.Pass();
 }
 
 // static
 cc::SurfaceId TypeConverter<cc::SurfaceId, SurfaceIdPtr>::Convert(
     const SurfaceIdPtr& input) {
-  return cc::SurfaceId(input->id);
+  uint64_t packed_id = input->id_namespace;
+  packed_id <<= 32ull;
+  packed_id |= input->local;
+  return cc::SurfaceId(packed_id);
 }
 
 // static
@@ -297,7 +302,7 @@ QuadPtr TypeConverter<QuadPtr, cc::DrawQuad>::Convert(
         vertex_opacity[i] = texture_quad->vertex_opacity[i];
       }
       texture_state->vertex_opacity = vertex_opacity.Pass();
-      texture_state->flipped = texture_quad->flipped;
+      texture_state->y_flipped = texture_quad->y_flipped;
       quad->texture_quad_state = texture_state.Pass();
       break;
     }
@@ -308,6 +313,7 @@ QuadPtr TypeConverter<QuadPtr, cc::DrawQuad>::Convert(
       tile_state->tex_coord_rect = RectF::From(tile_quad->tex_coord_rect);
       tile_state->texture_size = Size::From(tile_quad->texture_size);
       tile_state->swizzle_contents = tile_quad->swizzle_contents;
+      tile_state->nearest_neighbor = tile_quad->nearest_neighbor;
       tile_state->resource_id = tile_quad->resource_id;
       quad->tile_quad_state = tile_state.Pass();
       break;
@@ -316,7 +322,10 @@ QuadPtr TypeConverter<QuadPtr, cc::DrawQuad>::Convert(
       const cc::YUVVideoDrawQuad* yuv_quad =
           cc::YUVVideoDrawQuad::MaterialCast(&input);
       YUVVideoQuadStatePtr yuv_state = YUVVideoQuadState::New();
-      yuv_state->tex_coord_rect = RectF::From(yuv_quad->tex_coord_rect);
+      // TODO(sky): ya_tex_coord_rect
+      // TODO(sky): uv_tex_coord_rect
+      // TODO(sky): ya_texture_size
+      // TODO(sky): uv_texture_size
       yuv_state->y_plane_resource_id = yuv_quad->y_plane_resource_id;
       yuv_state->u_plane_resource_id = yuv_quad->u_plane_resource_id;
       yuv_state->v_plane_resource_id = yuv_quad->v_plane_resource_id;
@@ -354,7 +363,7 @@ TypeConverter<SharedQuadStatePtr, cc::SharedQuadState>::Convert(
 PassPtr TypeConverter<PassPtr, cc::RenderPass>::Convert(
     const cc::RenderPass& input) {
   PassPtr pass = Pass::New();
-  pass->id = input.id.index;
+  pass->id = RenderPassId::From(input.id);
   pass->output_rect = Rect::From(input.output_rect);
   pass->damage_rect = Rect::From(input.damage_rect);
   pass->transform_to_root_target =
@@ -393,7 +402,7 @@ TypeConverter<scoped_ptr<cc::RenderPass>, PassPtr>::Convert(
     const PassPtr& input) {
   scoped_ptr<cc::RenderPass> pass = cc::RenderPass::Create(
       input->shared_quad_states.size(), input->quads.size());
-  pass->SetAll(cc::RenderPassId(1, input->id),
+  pass->SetAll(input->id.To<cc::RenderPassId>(),
                input->output_rect.To<gfx::Rect>(),
                input->damage_rect.To<gfx::Rect>(),
                input->transform_to_root_target.To<gfx::Transform>(),
diff --git a/chromium/mojo/converters/surfaces/surfaces_type_converters.h b/chromium/mojo/converters/surfaces/surfaces_type_converters.h
index 5caf314632b..a5b0d45221e 100644
--- a/chromium/mojo/converters/surfaces/surfaces_type_converters.h
+++ b/chromium/mojo/converters/surfaces/surfaces_type_converters.h
@@ -9,12 +9,12 @@
 #include "cc/resources/returned_resource.h"
 #include "cc/resources/transferable_resource.h"
 #include "cc/surfaces/surface_id.h"
+#include "components/surfaces/public/interfaces/quads.mojom.h"
+#include "components/surfaces/public/interfaces/surface_id.mojom.h"
+#include "components/surfaces/public/interfaces/surfaces.mojom.h"
 #include "gpu/command_buffer/common/mailbox.h"
 #include "gpu/command_buffer/common/mailbox_holder.h"
 #include "mojo/converters/surfaces/mojo_surfaces_export.h"
-#include "mojo/services/public/interfaces/surfaces/quads.mojom.h"
-#include "mojo/services/public/interfaces/surfaces/surface_id.mojom.h"
-#include "mojo/services/public/interfaces/surfaces/surfaces.mojom.h"
 #include "third_party/skia/include/core/SkColor.h"
 
 namespace cc {
diff --git a/chromium/mojo/converters/surfaces/surfaces_utils.cc b/chromium/mojo/converters/surfaces/surfaces_utils.cc
index 05ccfe63ada..b433722aa40 100644
--- a/chromium/mojo/converters/surfaces/surfaces_utils.cc
+++ b/chromium/mojo/converters/surfaces/surfaces_utils.cc
@@ -5,6 +5,7 @@
 #include "mojo/converters/surfaces/surfaces_utils.h"
 
 #include "mojo/converters/geometry/geometry_type_converters.h"
+#include "mojo/converters/transform/transform_type_converters.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/transform.h"
@@ -26,7 +27,10 @@ SharedQuadStatePtr CreateDefaultSQS(const gfx::Size& size) {
 
 PassPtr CreateDefaultPass(int id, const gfx::Rect& rect) {
   PassPtr pass = Pass::New();
-  pass->id = id;
+  RenderPassId render_pass_id;
+  render_pass_id.layer_id = 1;
+  render_pass_id.index = id;
+  pass->id = render_pass_id.Clone();
   pass->output_rect = Rect::From(rect);
   pass->damage_rect = Rect::From(rect);
   pass->transform_to_root_target = Transform::From(gfx::Transform());
diff --git a/chromium/mojo/converters/surfaces/surfaces_utils.h b/chromium/mojo/converters/surfaces/surfaces_utils.h
index 70de8c0cbef..8b60cf0b704 100644
--- a/chromium/mojo/converters/surfaces/surfaces_utils.h
+++ b/chromium/mojo/converters/surfaces/surfaces_utils.h
@@ -5,8 +5,8 @@
 #ifndef MOJO_CONVERTERS_SURFACES_SURFACES_UTILS_H_
 #define MOJO_CONVERTERS_SURFACES_SURFACES_UTILS_H_
 
+#include "components/surfaces/public/interfaces/quads.mojom.h"
 #include "mojo/converters/surfaces/mojo_surfaces_export.h"
-#include "mojo/services/public/interfaces/surfaces/quads.mojom.h"
 
 namespace gfx {
 class Rect;
diff --git a/chromium/mojo/converters/transform/BUILD.gn b/chromium/mojo/converters/transform/BUILD.gn
new file mode 100644
index 00000000000..da04119fa8d
--- /dev/null
+++ b/chromium/mojo/converters/transform/BUILD.gn
@@ -0,0 +1,25 @@
+# Copyright 2015 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.
+
+component("transform") {
+  output_name = "mojo_transform_lib"
+
+  public_deps = [
+    "//ui/gfx",
+  ]
+  deps = [
+    "//skia",
+    "//mojo/environment:chromium",
+    "//third_party/mojo/src/mojo/public/c/system:for_component",
+    "//ui/mojo/geometry:interfaces",
+  ]
+
+  defines = [ "MOJO_TRANSFORM_IMPLEMENTATION" ]
+
+  sources = [
+    "mojo_transform_export.h",
+    "transform_type_converters.cc",
+    "transform_type_converters.h",
+  ]
+}
diff --git a/chromium/mojo/converters/transform/DEPS b/chromium/mojo/converters/transform/DEPS
new file mode 100644
index 00000000000..ed693dd115d
--- /dev/null
+++ b/chromium/mojo/converters/transform/DEPS
@@ -0,0 +1,4 @@
+include_rules = [
+  "+ui/gfx/transform.h",
+  "+ui/mojo/geometry",
+]
diff --git a/chromium/mojo/converters/transform/mojo_transform_export.h b/chromium/mojo/converters/transform/mojo_transform_export.h
new file mode 100644
index 00000000000..5dfc386935c
--- /dev/null
+++ b/chromium/mojo/converters/transform/mojo_transform_export.h
@@ -0,0 +1,32 @@
+// Copyright 2015 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 MOJO_CONVERTERS_TRANSFORM_MOJO_TRANSFORM_EXPORT_H_
+#define MOJO_CONVERTERS_TRANSFORM_MOJO_TRANSFORM_EXPORT_H_
+
+#if defined(COMPONENT_BUILD)
+
+#if defined(WIN32)
+
+#if defined(MOJO_TRANSFORM_IMPLEMENTATION)
+#define MOJO_TRANSFORM_EXPORT __declspec(dllexport)
+#else
+#define MOJO_TRANSFORM_EXPORT __declspec(dllimport)
+#endif
+
+#else  // !defined(WIN32)
+
+#if defined(MOJO_TRANSFORM_IMPLEMENTATION)
+#define MOJO_TRANSFORM_EXPORT __attribute__((visibility("default")))
+#else
+#define MOJO_TRANSFORM_EXPORT
+#endif
+
+#endif  // defined(WIN32)
+
+#else  // !defined(COMPONENT_BUILD)
+#define MOJO_TRANSFORM_EXPORT
+#endif
+
+#endif  // MOJO_CONVERTERS_TRANSFORM_MOJO_TRANSFORM_EXPORT_H_
diff --git a/chromium/mojo/converters/transform/transform_type_converters.cc b/chromium/mojo/converters/transform/transform_type_converters.cc
new file mode 100644
index 00000000000..92a53706f39
--- /dev/null
+++ b/chromium/mojo/converters/transform/transform_type_converters.cc
@@ -0,0 +1,31 @@
+// Copyright 2015 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 "mojo/converters/transform/transform_type_converters.h"
+
+namespace mojo {
+
+// static
+TransformPtr TypeConverter<TransformPtr, gfx::Transform>::Convert(
+    const gfx::Transform& input) {
+  std::vector<float> storage(16);
+  input.matrix().asRowMajorf(&storage[0]);
+  mojo::Array<float> matrix;
+  matrix.Swap(&storage);
+  TransformPtr transform(Transform::New());
+  transform->matrix = matrix.Pass();
+  return transform.Pass();
+}
+
+// static
+gfx::Transform TypeConverter<gfx::Transform, TransformPtr>::Convert(
+    const TransformPtr& input) {
+  if (input.is_null())
+    return gfx::Transform();
+  gfx::Transform transform(gfx::Transform::kSkipInitialization);
+  transform.matrix().setRowMajorf(&input->matrix.storage()[0]);
+  return transform;
+}
+
+}  // namespace mojo
diff --git a/chromium/mojo/converters/transform/transform_type_converters.h b/chromium/mojo/converters/transform/transform_type_converters.h
new file mode 100644
index 00000000000..372c4730d6f
--- /dev/null
+++ b/chromium/mojo/converters/transform/transform_type_converters.h
@@ -0,0 +1,25 @@
+// Copyright 2015 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 MOJO_CONVERTERS_TRANSFORM_TRANSFORM_TYPE_CONVERTERS_H_
+#define MOJO_CONVERTERS_TRANSFORM_TRANSFORM_TYPE_CONVERTERS_H_
+
+#include "mojo/converters/transform/mojo_transform_export.h"
+#include "ui/gfx/transform.h"
+#include "ui/mojo/geometry/geometry.mojom.h"
+
+namespace mojo {
+
+template <>
+struct MOJO_TRANSFORM_EXPORT TypeConverter<TransformPtr, gfx::Transform> {
+  static TransformPtr Convert(const gfx::Transform& input);
+};
+template <>
+struct MOJO_TRANSFORM_EXPORT TypeConverter<gfx::Transform, TransformPtr> {
+  static gfx::Transform Convert(const TransformPtr& input);
+};
+
+}  // namespace mojo
+
+#endif  // MOJO_CONVERTERS_TRANSFORM_TRANSFORM_TYPE_CONVERTERS_H_