Move scoped_nsdisable_screen_update from base to app/mac...

base/worker_pool_mac.mm

 // Copyright (c) 2010 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 "base/worker_pool_mac.h"
 
 #include "base/logging.h"
+#import "base/mac/scoped_nsautorelease_pool.h"
 #include "base/metrics/histogram.h"
-#import "base/scoped_nsautorelease_pool.h"
 #include "base/scoped_ptr.h"
 #import "base/singleton_objc.h"
 #include "base/task.h"
 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
 
 // When C++ exceptions are disabled, the C++ library defines |try| and
 // |catch| so as to allow exception-expecting C++ code to build properly when
 // language support for exceptions is not present.  These macros interfere
 // with the use of |@try| and |@catch| in Objective-C files such as this one.
 // Undefine these macros here, after everything has been #included, since
@@ skipping 56 matching lines @@
   DCHECK(task_.get()) << "-[TaskOperation main] called with no task";
   if (!task_.get()) {
     return;
   }
 
   {
     AutoLock locked(lock_);
     ++running_;
   }
 
-  base::ScopedNSAutoreleasePool autoreleasePool;
+  base::mac::ScopedNSAutoreleasePool autoreleasePool;
 
   @try {
     task_->Run();
   } @catch(NSException* exception) {
     LOG(ERROR) << "-[TaskOperation main] caught an NSException: "
                << [[exception description] UTF8String];
   } @catch(id exception) {
     LOG(ERROR) << "-[TaskOperation main] caught an unknown exception";
   }
 
@@ skipping 13 matching lines @@
   DCHECK(!task_.get())
       << "-[TaskOperation dealloc] called without running task";
   ANNOTATE_IGNORE_READS_END();
   [super dealloc];
 }
 
 @end  // @implementation TaskOperation
 
 bool WorkerPool::PostTask(const tracked_objects::Location& from_here,
                           Task* task, bool task_is_slow) {
-  base::ScopedNSAutoreleasePool autorelease_pool;
+  base::mac::ScopedNSAutoreleasePool autorelease_pool;
 
   // Ignore |task_is_slow|, it doesn't map directly to any tunable aspect of
   // an NSOperation.
 
   DCHECK(task) << "WorkerPool::PostTask called with no task";
   if (!task) {
     return false;
   }
 
   task->SetBirthPlace(from_here);
@@ skipping 19 matching lines @@
   size_t outstanding_delta = 0;
   size_t running_ops = 0;
   {
     const base::TimeDelta kCheckPeriod(base::TimeDelta::FromMinutes(10));
     base::Time now = base::Time::Now();
 
     AutoLock locked(lock_);
     ++outstanding_;
     running_ops = running_;
     if (last_check_.is_null() || now - last_check_ > kCheckPeriod) {
-      base::ScopedNSAutoreleasePool autoreleasePool;
+      base::mac::ScopedNSAutoreleasePool autoreleasePool;
       std::vector<id> ops;
       for (id op in [operation_queue operations]) {
         // DO NOT RETAIN.
         ops.push_back(op);
       }
       std::sort(ops.begin(), ops.end());
 
       outstanding_delta = outstanding_ - ops.size();
 
       std::set_intersection(outstanding_ops_.begin(), outstanding_ops_.end(),
                             ops.begin(), ops.end(),
                             std::back_inserter(hung_ops));
 
       outstanding_ops_.swap(ops);
       last_check_ = now;
     }
   }
 
   // Don't report "nothing to report".
   const size_t kUnaccountedOpsDelta = 10;
   if (hung_ops.size() > 0 || outstanding_delta > kUnaccountedOpsDelta) {
     UMA_HISTOGRAM_COUNTS_100("OSX.HungWorkers", hung_ops.size());
     UMA_HISTOGRAM_COUNTS_100("OSX.OutstandingDelta", outstanding_delta);
     UMA_HISTOGRAM_COUNTS_100("OSX.RunningOps", running_ops);
   }
 
   return true;
 }