Use container::back() and container::pop_back() in ui/

ui/ozone/platform/drm/gpu/drm_device.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/ozone/platform/drm/gpu/drm_device.h"
 
 #include <fcntl.h>
 #include <sys/mman.h>
 #include <unistd.h>
 #include <xf86drm.h>
@@ skipping 260 matching lines @@
       result[i].r = lut_in[base_index].r +
                     (lut_in[base_index + 1].r - lut_in[base_index].r) *
                         remaining / desired_size;
       result[i].g = lut_in[base_index].g +
                     (lut_in[base_index + 1].g - lut_in[base_index].g) *
                         remaining / desired_size;
       result[i].b = lut_in[base_index].b +
                     (lut_in[base_index + 1].b - lut_in[base_index].b) *
                         remaining / desired_size;
     } else {
-      result[i] = lut_in[lut_in.size() - 1];
+      result[i] = lut_in.back();
     }
   }
 
   return result;
 }
 
 }  // namespace
 
 class DrmDevice::PageFlipManager {
  public:
   PageFlipManager() : next_id_(0) {}
   ~PageFlipManager() {}
 
   void OnPageFlip(uint32_t frame,
                   uint32_t seconds,
                   uint32_t useconds,
                   uint64_t id) {
     auto it =
         std::find_if(callbacks_.begin(), callbacks_.end(), FindCallback(id));
     if (it == callbacks_.end()) {
       LOG(WARNING) << "Could not find callback for page flip id=" << id;
       return;
     }
 
     DrmDevice::PageFlipCallback callback = it->callback;
-    it->pending_calls -= 1;
-
+    it->pending_calls--;
     if (it->pending_calls)
       return;
 
     callbacks_.erase(it);
     callback.Run(frame, seconds, useconds);
   }
 
   uint64_t GetNextId() { return next_id_++; }
 
   void RegisterCallback(uint64_t id,
                         uint64_t pending_calls,
                         const DrmDevice::PageFlipCallback& callback) {
     callbacks_.push_back({id, pending_calls, callback});
   }
 
  private:
   struct PageFlip {
     uint64_t id;
     uint32_t pending_calls;
     DrmDevice::PageFlipCallback callback;
   };
 
   struct FindCallback {
-    FindCallback(uint64_t id) : id(id) {}
+    explicit FindCallback(uint64_t id) : id(id) {}
 
     bool operator()(const PageFlip& flip) const { return flip.id == id; }
 
-    uint64_t id;
+    const uint64_t id;
   };
 
   uint64_t next_id_;
 
   std::vector<PageFlip> callbacks_;
 
   DISALLOW_COPY_AND_ASSIGN(PageFlipManager);
 };
 
 class DrmDevice::IOWatcher : public base::MessagePumpLibevent::Watcher {
@@ skipping 452 matching lines @@
               reinterpret_cast<unsigned char*>(ctm_blob_data.get()),
               sizeof(DrmColorCtm)))
         return false;
     }
   }
 
   return true;
 }
 
 }  // namespace ui