Remove obsolete scale related APIs for cursor

ui/wm/core/cursor_manager.cc

 // Copyright (c) 2013 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 "ui/wm/core/cursor_manager.h"
 
 #include "base/logging.h"
 #include "ui/aura/client/cursor_client_observer.h"
 #include "ui/wm/core/native_cursor_manager.h"
 #include "ui/wm/core/native_cursor_manager_delegate.h"
 
 namespace wm {
 
 namespace internal {
 
 // Represents the cursor state which is composed of cursor type, visibility, and
 // mouse events enable state. When mouse events are disabled, the cursor is
 // always invisible.
 class CursorState {
  public:
   CursorState()
       : cursor_(ui::kCursorNone),
         visible_(true),
-        scale_(1.f),
         cursor_set_(ui::CURSOR_SET_NORMAL),
         mouse_events_enabled_(true),
         visible_on_mouse_events_enabled_(true) {
   }
 
   gfx::NativeCursor cursor() const { return cursor_; }
   void set_cursor(gfx::NativeCursor cursor) { cursor_ = cursor; }
 
   bool visible() const { return visible_; }
   void SetVisible(bool visible) {
     if (mouse_events_enabled_)
       visible_ = visible;
     // Ignores the call when mouse events disabled.
   }
 
-  float scale() const { return scale_; }
-  void set_scale(float scale) {
-    scale_ = scale;
-  }
-
   ui::CursorSetType cursor_set() const { return cursor_set_; }
   void set_cursor_set(ui::CursorSetType cursor_set) {
     cursor_set_ = cursor_set;
   }
 
   bool mouse_events_enabled() const { return mouse_events_enabled_; }
   void SetMouseEventsEnabled(bool enabled) {
     if (mouse_events_enabled_ == enabled)
       return;
     mouse_events_enabled_ = enabled;
 
     // Restores the visibility when mouse events are enabled.
     if (enabled) {
       visible_ = visible_on_mouse_events_enabled_;
     } else {
       visible_on_mouse_events_enabled_ = visible_;
       visible_ = false;
     }
   }
 
  private:
   gfx::NativeCursor cursor_;
   bool visible_;
-  float scale_;
   ui::CursorSetType cursor_set_;
   bool mouse_events_enabled_;
 
   // The visibility to set when mouse events are enabled.
   bool visible_on_mouse_events_enabled_;
 
   DISALLOW_COPY_AND_ASSIGN(CursorState);
 };
 
 }  // namespace internal
@@ skipping 37 matching lines @@
     delegate_->SetVisibility(state_on_unlock_->visible(), this);
     FOR_EACH_OBSERVER(aura::client::CursorClientObserver, observers_,
                       OnCursorVisibilityChanged(false));
   }
 }
 
 bool CursorManager::IsCursorVisible() const {
   return current_state_->visible();
 }
 
-void CursorManager::SetScale(float scale) {
-  state_on_unlock_->set_scale(scale);
-  if (GetScale() != state_on_unlock_->scale())
-    delegate_->SetScale(state_on_unlock_->scale(), this);
-}
-
-float CursorManager::GetScale() const {
-  return current_state_->scale();
-}
-
 void CursorManager::SetCursorSet(ui::CursorSetType cursor_set) {
   state_on_unlock_->set_cursor_set(cursor_set);
   if (GetCursorSet() != state_on_unlock_->cursor_set())
     delegate_->SetCursorSet(state_on_unlock_->cursor_set(), this);
 }
 
 ui::CursorSetType CursorManager::GetCursorSet() const {
   return current_state_->cursor_set();
 }
 
@@ skipping 70 matching lines @@
 }
 
 void CursorManager::CommitVisibility(bool visible) {
   // TODO(tdanderson): Find a better place for this so we don't
   // notify the observers more than is necessary.
   FOR_EACH_OBSERVER(aura::client::CursorClientObserver, observers_,
                     OnCursorVisibilityChanged(visible));
   current_state_->SetVisible(visible);
 }
 
-void CursorManager::CommitScale(float scale) {
-  current_state_->set_scale(scale);
-}
-
 void CursorManager::CommitCursorSet(ui::CursorSetType cursor_set) {
   current_state_->set_cursor_set(cursor_set);
 }
 
 void CursorManager::CommitMouseEventsEnabled(bool enabled) {
   current_state_->SetMouseEventsEnabled(enabled);
 }
 
 }  // namespace wm