Use scoped_ptr for memory management rather than calling delete through WindowSizer.

chrome/browser/ui/window_sizer.cc

 // Copyright (c) 2011 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 "chrome/browser/ui/window_sizer.h"
 
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
@@ skipping 84 matching lines @@
   std::string app_name_;
 
   // If set, is used as the reference browser for GetLastActiveWindowState.
   const Browser* browser_;
   DISALLOW_COPY_AND_ASSIGN(DefaultStateProvider);
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // WindowSizer, public:
 
-WindowSizer::WindowSizer(
-    StateProvider* state_provider,
-    MonitorInfoProvider* monitor_info_provider)
+WindowSizer::WindowSizer(StateProvider* state_provider,
+                         MonitorInfoProvider* monitor_info_provider)
     : state_provider_(state_provider),
       monitor_info_provider_(monitor_info_provider) {
 }
 
 WindowSizer::~WindowSizer() {
-  if (state_provider_)
-    delete state_provider_;
-  if (monitor_info_provider_)
-    delete monitor_info_provider_;
 }
 
 // static
 void WindowSizer::GetBrowserWindowBounds(const std::string& app_name,
                                          const gfx::Rect& specified_bounds,
                                          const Browser* browser,
                                          gfx::Rect* window_bounds) {
   const WindowSizer sizer(new DefaultStateProvider(app_name, browser),
                           CreateDefaultMonitorInfoProvider());
   sizer.DetermineWindowBounds(specified_bounds, window_bounds);
@@ skipping 12 matching lines @@
         // No saved placement, figure out some sensible default size based on
         // the user's screen size.
         GetDefaultWindowBounds(bounds);
       }
     }
   }
 }
 
 bool WindowSizer::GetLastWindowBounds(gfx::Rect* bounds) const {
   DCHECK(bounds);
-  if (!state_provider_ || !state_provider_->GetLastActiveWindowState(bounds))
+  if (!state_provider_.get() ||
+      !state_provider_->GetLastActiveWindowState(bounds))
     return false;
   gfx::Rect last_window_bounds = *bounds;
   bounds->Offset(kWindowTilePixels, kWindowTilePixels);
   AdjustBoundsToBeVisibleOnMonitorContaining(last_window_bounds,
                                              gfx::Rect(),
                                              bounds);
   return true;
 }
 
 bool WindowSizer::GetSavedWindowBounds(gfx::Rect* bounds) const {
   DCHECK(bounds);
   gfx::Rect saved_work_area;
-  if (!state_provider_ ||
+  if (!state_provider_.get() ||
       !state_provider_->GetPersistentState(bounds, &saved_work_area))
     return false;
   AdjustBoundsToBeVisibleOnMonitorContaining(*bounds, saved_work_area, bounds);
   return true;
 }
 
 void WindowSizer::GetDefaultWindowBounds(gfx::Rect* default_bounds) const {
   DCHECK(default_bounds);
-  DCHECK(monitor_info_provider_);
+  DCHECK(monitor_info_provider_.get());
 
   gfx::Rect work_area = monitor_info_provider_->GetPrimaryMonitorWorkArea();
 
   // The default size is either some reasonably wide width, or if the work
   // area is narrower, then the work area width less some aesthetic padding.
   int default_width = std::min(work_area.width() - 2 * kWindowTilePixels, 1050);
   int default_height = work_area.height() - 2 * kWindowTilePixels;
 
   // For wider aspect ratio displays at higher resolutions, we might size the
   // window narrower to allow two windows to easily be placed side-by-side.
@@ skipping 12 matching lines @@
     // kWindowTilePixels between screen edge and each other.
     default_width = static_cast<int>(work_area.width() / 2. -
         1.5 * kWindowTilePixels);
   }
   default_bounds->SetRect(kWindowTilePixels + work_area.x(),
                           kWindowTilePixels + work_area.y(),
                           default_width, default_height);
 }
 
 bool WindowSizer::PositionIsOffscreen(int position, Edge edge) const {
-  DCHECK(monitor_info_provider_);
+  DCHECK(monitor_info_provider_.get());
   size_t monitor_count = monitor_info_provider_->GetMonitorCount();
   for (size_t i = 0; i < monitor_count; ++i) {
     gfx::Rect work_area = monitor_info_provider_->GetWorkAreaAt(i);
     switch (edge) {
       case TOP:
         if (position >= work_area.y())
           return false;
         break;
       case LEFT:
         if (position >= work_area.x())
@@ skipping 17 matching lines @@
   static const int kMinVisibleHeight = 30;
   // Minimum width of the visible part of a window.
   static const int kMinVisibleWidth = 30;
 }
 
 void WindowSizer::AdjustBoundsToBeVisibleOnMonitorContaining(
     const gfx::Rect& other_bounds,
     const gfx::Rect& saved_work_area,
     gfx::Rect* bounds) const {
   DCHECK(bounds);
-  DCHECK(monitor_info_provider_);
+  DCHECK(monitor_info_provider_.get());
 
   // Find the size of the work area of the monitor that intersects the bounds
   // of the anchor window.
   gfx::Rect work_area =
       monitor_info_provider_->GetMonitorWorkAreaMatching(other_bounds);
 
   // If height or width are 0, reset to the default size.
   gfx::Rect default_bounds;
   GetDefaultWindowBounds(&default_bounds);
   if (bounds->height() <= 0)
@@ skipping 47 matching lines @@
   // On non-Mac platforms, we are less aggressive about repositioning.  Simply
   // ensure that at least kMinVisibleWidth * kMinVisibleHeight is visible.
   const int min_y = work_area.y() + kMinVisibleHeight - bounds->height();
   const int min_x = work_area.x() + kMinVisibleWidth - bounds->width();
   const int max_y = work_area.bottom() - kMinVisibleHeight;
   const int max_x = work_area.right() - kMinVisibleWidth;
   bounds->set_y(std::max(min_y, std::min(max_y, bounds->y())));
   bounds->set_x(std::max(min_x, std::min(max_x, bounds->x())));
 #endif  // defined(OS_MACOSX)
 }