Replace unique_ptr.reset/release with std::move under src/ui

ui/views/controls/menu/menu_controller.cc

 // 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.
 
 #include "ui/views/controls/menu/menu_controller.h"
 
 #include "base/i18n/case_conversion.h"
 #include "base/i18n/rtl.h"
 #include "base/macros.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 408 matching lines @@
   // If we are already showing, this new menu is being nested. Such as context
   // menus on top of normal menus.
   if (showing_) {
     // Only support nesting of blocking_run menus, nesting of
     // blocking/non-blocking shouldn't be needed.
     DCHECK(blocking_run_);
 
     state_.hot_button = hot_button_;
     hot_button_ = nullptr;
     // We're already showing, push the current state.
-    menu_stack_.push_back(
-        std::make_pair(state_, make_linked_ptr(pressed_lock_.release())));
+    menu_stack_.push_back(std::make_pair(state_, std::move(pressed_lock_)));
 
     // The context menu should be owned by the same parent.
     DCHECK_EQ(owner_, parent);
   } else {
     showing_ = true;
 
     if (owner_)
       owner_->RemoveObserver(this);
     owner_ = parent;
     if (owner_)
@@ skipping 408 matching lines @@
   if (!details.is_add) {
     // If the current mouse handler is removed, remove it as the handler.
     if (details.child == current_mouse_event_target_) {
       current_mouse_event_target_ = nullptr;
       current_mouse_pressed_state_ = 0;
     }
     // Update |hot_button_| (both in |this| and in |menu_stack_| if it gets
     // removed while a menu is up.
     if (details.child == hot_button_) {
       hot_button_ = nullptr;
-      for (auto nested_state : menu_stack_) {
+      for (auto&& nested_state : menu_stack_) {

[sky, 2016/12/06 14:16:06]

optional: const on 858 and 859?

[Sunny, 2016/12/07 04:57:38]

Hi, thanks for the review

Since 861 changes member "hot_button" in state, maybe it's not possible to make
858 and 859 const?

[sky, 2016/12/07 16:48:24]

You are right.

         State& state = nested_state.first;
         if (details.child == state.hot_button)
           state.hot_button = nullptr;
       }
     }
   }
 }
 
 bool MenuController::GetDropFormats(
       SubmenuView* source,
@@ skipping 686 matching lines @@
 
   if (menu_item->GetDelegate()->ShowContextMenu(
           menu_item, menu_item->GetCommand(), screen_location, source_type)) {
     SendMouseCaptureLostToActiveView();
     return true;
   }
   return false;
 }
 
 void MenuController::CloseAllNestedMenus() {
-  for (std::list<NestedState>::iterator i = menu_stack_.begin();
-       i != menu_stack_.end(); ++i) {
-    State& state = i->first;
+  for (auto&& nested_menu : menu_stack_) {
+    State& state = nested_menu.first;
     MenuItemView* last_item = state.item;
     for (MenuItemView* item = last_item; item;
          item = item->GetParentMenuItem()) {
       CloseMenu(item);
       last_item = item;
     }
     state.submenu_open = false;
     state.item = last_item;
   }
 }
@@ skipping 1028 matching lines @@
     POINT cursor_pos;
     ::GetCursorPos(&cursor_pos);
     HWND window = ::WindowFromPoint(cursor_pos);
     if (::GetWindowThreadProcessId(window, nullptr) == ::GetCurrentThreadId()) {
       ::SetProp(window, ui::kIgnoreTouchMouseActivateForWindow,
                 reinterpret_cast<HANDLE>(true));
     }
   }
 #endif
 
-  linked_ptr<MenuButton::PressedLock> nested_pressed_lock;
+  std::unique_ptr<MenuButton::PressedLock> nested_pressed_lock;
   bool nested_menu = !menu_stack_.empty();
   if (nested_menu) {
     DCHECK(!menu_stack_.empty());
     // We're running from within a menu, restore the previous state.
     // The menus are already showing, so we don't have to show them.
     state_ = menu_stack_.back().first;
     pending_state_ = menu_stack_.back().first;
     hot_button_ = state_.hot_button;
-    nested_pressed_lock = menu_stack_.back().second;
+    nested_pressed_lock = std::move(menu_stack_.back().second);
     menu_stack_.pop_back();
     // Even though the menus are nested, there may not be nested delegates.
     if (delegate_stack_.size() > 1) {
       delegate_stack_.pop_back();
       delegate_ = delegate_stack_.back().first;
       async_run_ = delegate_stack_.back().second;
     }
   } else {
 #if defined(USE_AURA)
     menu_pre_target_handler_.reset();
@@ skipping 20 matching lines @@
       // Set exit_all_, which makes sure all nested loops exit immediately.
       if (exit_type_ != EXIT_DESTROYED)
         SetExitType(EXIT_ALL);
     } else {
       TerminateNestedMessageLoopIfNecessary();
     }
   }
 
   // Reset our pressed lock and hot-tracked state to the previous state's, if
   // they were active. The lock handles the case if the button was destroyed.
-  pressed_lock_.reset(nested_pressed_lock.release());
+  pressed_lock_ = std::move(nested_pressed_lock);
   if (hot_button_)
     hot_button_->SetHotTracked(true);
 
   return result;
 }
 
 void MenuController::HandleMouseLocation(SubmenuView* source,
                                          const gfx::Point& mouse_location) {
   if (showing_submenu_)
     return;
@@ skipping 48 matching lines @@
   if (hot_button_)
     hot_button_->SetHotTracked(false);
   hot_button_ = hot_button;
   if (hot_button) {
     hot_button->SetHotTracked(true);
     hot_button->NotifyAccessibilityEvent(ui::AX_EVENT_SELECTION, true);
   }
 }
 
 }  // namespace views