Remove Event::system_location

ui/base/events/event.h

 // Copyright (c) 2012 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 UI_BASE_EVENTS_EVENT_H_
 #define UI_BASE_EVENTS_EVENT_H_
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/event_types.h"
@@ skipping 196 matching lines @@
 
   void set_name(const std::string& name) { name_ = name; }
 
  private:
   void operator=(const Event&);
 
   // Safely initializes the native event members of this class.
   void Init();
   void InitWithNativeEvent(const base::NativeEvent& native_event);
 
-  base::NativeEvent native_event_;
   EventType type_;
   std::string name_;
   base::TimeDelta time_stamp_;
   int flags_;
   bool dispatch_to_hidden_targets_;
+  base::NativeEvent native_event_;
   bool delete_native_event_;
   bool cancelable_;
   EventTarget* target_;
   EventPhase phase_;
   EventResult result_;
 };
 
 class UI_EXPORT CancelModeEvent : public Event {
  public:
   CancelModeEvent();
@@ skipping 22 matching lines @@
 
   int x() const { return location_.x(); }
   int y() const { return location_.y(); }
   void set_location(const gfx::Point& location) { location_ = location; }
   gfx::Point location() const { return location_; }
   void set_root_location(const gfx::Point& root_location) {
     root_location_ = root_location;
   }
   gfx::Point root_location() const { return root_location_; }
 
-  bool valid_system_location() const { return valid_system_location_; }
-  void set_system_location(const gfx::Point& loc) {
-    valid_system_location_ = true;
-    system_location_ = loc;
-  }
-  const gfx::Point& system_location() const { return system_location_; }
-
   // Transform the locations using |inverted_root_transform|.
   // This is applied to both |location_| and |root_location_|.
   virtual void UpdateForRootTransform(
       const gfx::Transform& inverted_root_transform);
 
   template <class T> void ConvertLocationToTarget(T* source, T* target) {
     if (target && target != source)
       T::ConvertPointToTarget(source, target, &location_);
   }
 
  protected:
   explicit LocatedEvent(const base::NativeEvent& native_event);
 
   // Create a new LocatedEvent which is identical to the provided model.
   // If source / target windows are provided, the model location will be
   // converted from |source| coordinate system to |target| coordinate system.
   template <class T>
   LocatedEvent(const LocatedEvent& model, T* source, T* target)
       : Event(model),
         location_(model.location_),
-        root_location_(model.root_location_),
-        valid_system_location_(model.valid_system_location_),
-        system_location_(model.system_location_) {
-    // TODO(erg): May need to create system_location_ by converting location to
-    // system coordinates here.
+        root_location_(model.root_location_) {
     ConvertLocationToTarget(source, target);
   }
 
   // Used for synthetic events in testing.
   LocatedEvent(EventType type,
                const gfx::Point& location,
                const gfx::Point& root_location,
                base::TimeDelta time_stamp,
                int flags);
 
   gfx::Point location_;
 
   // |location_| multiplied by an optional transformation matrix for
   // rotations, animations and skews.
   gfx::Point root_location_;
-
-  // |location_| in underlying system screen coordinates. This can be invalid
-  // |during synthesized events if a location isn't explicitly set.
-  bool valid_system_location_;
-  gfx::Point system_location_;
 };
 
 class UI_EXPORT MouseEvent : public LocatedEvent {
  public:
   explicit MouseEvent(const base::NativeEvent& native_event);
 
   // Create a new MouseEvent based on the provided model.
   // Uses the provided |type| and |flags| for the new event.
   // If source / target windows are provided, the model location will be
   // converted from |source| coordinate system to |target| coordinate system.
@@ skipping 383 matching lines @@
   // This value is stored as a bitfield because the number of touch ids varies,
   // but we currently don't need more than 32 touches at a time.
   const unsigned int touch_ids_bitfield_;
 
   DISALLOW_COPY_AND_ASSIGN(GestureEvent);
 };
 
 }  // namespace ui
 
 #endif  // UI_BASE_EVENTS_EVENT_H_