Replace VLOG(0) with VLOG(1) in accessibility code

ui/chromeos/touch_exploration_controller.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 "ui/chromeos/touch_exploration_controller.h"
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "ui/accessibility/ax_enums.h"
 #include "ui/aura/client/cursor_client.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/events/event.h"
 #include "ui/events/event_processor.h"
 #include "ui/events/event_utils.h"
 #include "ui/gfx/geometry/rect.h"
 
 #define SET_STATE(state) SetState(state, __func__)
-#define VLOG_EVENT(event) if (VLOG_IS_ON(0)) VlogEvent(event, __func__)
+#define VLOG_EVENT(event) \
+  if (VLOG_IS_ON(1))      \
+  VlogEvent(event, __func__)
 
 namespace ui {
 
 namespace {
 
 // Delay between adjustment sounds.
 const int kSoundDelayInMS = 150;
 
 void SetTouchAccessibilityFlag(ui::Event* event) {
   // This flag is used to identify mouse move events that were generated from
@@ skipping 33 matching lines @@
 void TouchExplorationController::SetExcludeBounds(const gfx::Rect& bounds) {
   exclude_bounds_ = bounds;
 }
 
 ui::EventRewriteStatus TouchExplorationController::RewriteEvent(
     const ui::Event& event,
     std::unique_ptr<ui::Event>* rewritten_event) {
   if (!event.IsTouchEvent()) {
     if (event.IsKeyEvent()) {
       const ui::KeyEvent& key_event = static_cast<const ui::KeyEvent&>(event);
-      VLOG(0) << "\nKeyboard event: " << key_event.name()
+      VLOG(1) << "\nKeyboard event: " << key_event.name()
               << "\n Key code: " << key_event.key_code()
               << ", Flags: " << key_event.flags()
               << ", Is char: " << key_event.is_char();
     }
     return ui::EVENT_REWRITE_CONTINUE;
   }
   const ui::TouchEvent& touch_event = static_cast<const ui::TouchEvent&>(event);
 
   if (!exclude_bounds_.IsEmpty()) {
     gfx::Point location = touch_event.location();
@@ skipping 66 matching lines @@
     return ui::EVENT_REWRITE_CONTINUE;
   }
   VLOG_EVENT(touch_event);
 
   // In order to avoid accidentally double tapping when moving off the edge
   // of the screen, the state will be rewritten to NoFingersDown.
   if ((type == ui::ET_TOUCH_RELEASED || type == ui::ET_TOUCH_CANCELLED) &&
       FindEdgesWithinBounds(touch_event.location(), kLeavingScreenEdge) !=
           NO_EDGE) {
     if (VLOG_on_)
-      VLOG(0) << "Leaving screen";
+      VLOG(1) << "Leaving screen";
 
     // Indicates to the user that they are leaving the screen.
     delegate_->PlayExitScreenEarcon();
 
     if (current_touch_ids_.size() == 0) {
       SET_STATE(NO_FINGERS_DOWN);
       if (VLOG_on_) {
-        VLOG(0) << "Reset to no fingers in Rewrite event because the touch  "
+        VLOG(1) << "Reset to no fingers in Rewrite event because the touch  "
                    "release or cancel was on the edge of the screen.";
       }
       return ui::EVENT_REWRITE_DISCARD;
     }
   }
 
   // If the user is in a gesture state, or if there is a possiblity that the
   // user will enter it in the future, we send the event to the gesture
   // provider so it can keep track of the state of the fingers. When the user
   // leaves one of these states, SET_STATE will set the gesture provider to
@@ skipping 141 matching lines @@
     // If the user does not move far enough from the original position, then the
     // resulting movement should not be considered to be a deliberate gesture or
     // touch exploration.
     if (distance <= gesture_detector_config_.touch_slop)
       return EVENT_REWRITE_DISCARD;
 
     float delta_time =
         (event.time_stamp() - initial_press_->time_stamp()).InSecondsF();
     float velocity = distance / delta_time;
     if (VLOG_on_) {
-      VLOG(0) << "\n Delta time: " << delta_time << "\n Distance: " << distance
+      VLOG(1) << "\n Delta time: " << delta_time << "\n Distance: " << distance
               << "\n Velocity of click: " << velocity
               << "\n Minimum swipe velocity: "
               << gesture_detector_config_.minimum_swipe_velocity;
     }
     // Change to slide gesture if the slide occurred at the right edge.
     int edge = FindEdgesWithinBounds(event.location(), kMaxDistanceFromEdge);
     if (edge & RIGHT_EDGE && edge != BOTTOM_RIGHT_CORNER) {
       SET_STATE(SLIDE_GESTURE);
       return InSlideGesture(event, rewritten_event);
     }
@@ skipping 547 matching lines @@
     return;
   }
 
   location = gesture->location();
   root_window_->GetHost()->ConvertPointFromNativeScreen(&location);
   float volume_adjust_height =
       root_window_->bounds().height() - 2 * kMaxDistanceFromEdge;
   float ratio = (location.y() - kMaxDistanceFromEdge) / volume_adjust_height;
   float volume = 100 - 100 * ratio;
   if (VLOG_on_) {
-    VLOG(0) << "\n Volume = " << volume
+    VLOG(1) << "\n Volume = " << volume
             << "\n Location = " << location.ToString()
             << "\n Bounds = " << root_window_->bounds().right();
   }
   delegate_->SetOutputLevel(static_cast<int>(volume));
 }
 
 void TouchExplorationController::OnSwipeEvent(ui::GestureEvent* swipe_gesture) {
   // A swipe gesture contains details for the direction in which the swipe
   // occurred. TODO(evy) : Research which swipe results users most want and
   // remap these swipes to the best events. Hopefully in the near future
   // there will also be a menu for users to pick custom mappings.
   GestureEventDetails event_details = swipe_gesture->details();
   int num_fingers = event_details.touch_points();
   if (VLOG_on_)
-    VLOG(0) << "\nSwipe with " << num_fingers << " fingers.";
+    VLOG(1) << "\nSwipe with " << num_fingers << " fingers.";
 
   ui::AXGesture gesture = ui::AX_GESTURE_NONE;
   if (event_details.swipe_left()) {
     switch (num_fingers) {
       case 1:
         gesture = ui::AX_GESTURE_SWIPE_LEFT_1;
         break;
       case 2:
         gesture = ui::AX_GESTURE_SWIPE_LEFT_2;
         break;
@@ skipping 92 matching lines @@
 }
 
 void TouchExplorationController::DispatchKeyWithFlags(
     const ui::KeyboardCode key,
     int flags) {
   ui::KeyEvent key_down(ui::ET_KEY_PRESSED, key, flags);
   ui::KeyEvent key_up(ui::ET_KEY_RELEASED, key, flags);
   DispatchEvent(&key_down);
   DispatchEvent(&key_up);
   if (VLOG_on_) {
-    VLOG(0) << "\nKey down: key code : " << key_down.key_code()
+    VLOG(1) << "\nKey down: key code : " << key_down.key_code()
             << ", flags: " << key_down.flags()
             << "\nKey up: key code : " << key_up.key_code()
             << ", flags: " << key_up.flags();
   }
 }
 
 base::Closure TouchExplorationController::BindKeyEventWithFlags(
     const ui::KeyboardCode key,
     int flags) {
   return base::Bind(&TouchExplorationController::DispatchKeyWithFlags,
@@ skipping 71 matching lines @@
   }
 }
 
 void TouchExplorationController::VlogState(const char* function_name) {
   if (!VLOG_on_)
     return;
   if (prev_state_ == state_)
     return;
   prev_state_ = state_;
   const char* state_string = EnumStateToString(state_);
-  VLOG(0) << "\n Function name: " << function_name
+  VLOG(1) << "\n Function name: " << function_name
           << "\n State: " << state_string;
 }
 
 void TouchExplorationController::VlogEvent(const ui::TouchEvent& touch_event,
                                            const char* function_name) {
   if (!VLOG_on_)
     return;
 
   if (prev_event_ && prev_event_->type() == touch_event.type() &&
       prev_event_->touch_id() == touch_event.touch_id()) {
     return;
   }
   // The above statement prevents events of the same type and id from being
   // printed in a row. However, if two fingers are down, they would both be
   // moving and alternating printing move events unless we check for this.
   if (prev_event_ && prev_event_->type() == ET_TOUCH_MOVED &&
       touch_event.type() == ET_TOUCH_MOVED) {
     return;
   }
 
   const std::string& type = touch_event.name();
   const gfx::PointF& location = touch_event.location_f();
   const int touch_id = touch_event.touch_id();
 
-  VLOG(0) << "\n Function name: " << function_name
-          << "\n Event Type: " << type
+  VLOG(1) << "\n Function name: " << function_name << "\n Event Type: " << type
           << "\n Location: " << location.ToString()
           << "\n Touch ID: " << touch_id;
   prev_event_.reset(new TouchEvent(touch_event));
 }
 
 const char* TouchExplorationController::EnumStateToString(State state) {
   switch (state) {
     case NO_FINGERS_DOWN:
       return "NO_FINGERS_DOWN";
     case SINGLE_TAP_PRESSED:
@@ skipping 24 matching lines @@
       return "TWO_FINGER_TAP";
   }
   return "Not a state";
 }
 
 float TouchExplorationController::GetSplitTapTouchSlop() {
   return gesture_detector_config_.touch_slop * 3;
 }
 
 }  // namespace ui