chrome: Use base::MessageLoop. (Part 3)

chrome/browser/chromeos/memory/low_memory_observer.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 "chrome/browser/chromeos/memory/low_memory_observer.h"
 
 #include <fcntl.h>
 
 #include "base/bind.h"
 #include "base/chromeos/chromeos_version.h"
@@ skipping 55 matching lines @@
     StopObservingOnFileThread();
   }
 
   // Start a timer to resume watching the low memory file descriptor.
   void ScheduleNextObservation();
 
   // Actually start watching the file descriptor.
   void StartWatchingDescriptor();
 
   // Delegate to receive events from WatchFileDescriptor.
-  class FileWatcherDelegate : public MessageLoopForIO::Watcher {
+  class FileWatcherDelegate : public base::MessageLoopForIO::Watcher {
    public:
     explicit FileWatcherDelegate(LowMemoryObserverImpl* owner)
         : owner_(owner) {}
     virtual ~FileWatcherDelegate() {}
 
     // Overrides for MessageLoopForIO::Watcher
     virtual void OnFileCanWriteWithoutBlocking(int fd) OVERRIDE {}
     virtual void OnFileCanReadWithoutBlocking(int fd) OVERRIDE {
       LOG(WARNING) << "Low memory condition detected.  Discarding a tab.";
       // We can only discard tabs on the UI thread.
       base::Callback<void(void)> callback = base::Bind(&DiscardTab);
       BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, callback);
       owner_->ScheduleNextObservation();
     }
 
     // Sends off a discard request to the OomPriorityManager.  Must be run on
     // the UI thread.
     static void DiscardTab() {
       CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
       if (g_browser_process && g_browser_process->oom_priority_manager())
         g_browser_process->oom_priority_manager()->LogMemoryAndDiscardTab();
     }
 
    private:
     LowMemoryObserverImpl* owner_;
     DISALLOW_COPY_AND_ASSIGN(FileWatcherDelegate);
   };
 
-  scoped_ptr<MessageLoopForIO::FileDescriptorWatcher> watcher_;
+  scoped_ptr<base::MessageLoopForIO::FileDescriptorWatcher> watcher_;
   FileWatcherDelegate watcher_delegate_;
   int file_descriptor_;
   base::OneShotTimer<LowMemoryObserverImpl> timer_;
 
   DISALLOW_COPY_AND_ASSIGN(LowMemoryObserverImpl);
 };
 
 void LowMemoryObserverImpl::StartObservingOnFileThread() {
   DCHECK_LE(file_descriptor_, 0)
       << "Attempted to start observation when it was already started.";
   DCHECK(watcher_.get() == NULL);
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
-  DCHECK(MessageLoopForIO::current());
+  DCHECK(base::MessageLoopForIO::current());
 
   file_descriptor_ = ::open(kLowMemFile, O_RDONLY);
   // Don't report this error unless we're really running on ChromeOS
   // to avoid testing spam.
   if (file_descriptor_ < 0 && base::chromeos::IsRunningOnChromeOS()) {
     PLOG(ERROR) << "Unable to open " << kLowMemFile;
     return;
   }
-  watcher_.reset(new MessageLoopForIO::FileDescriptorWatcher);
+  watcher_.reset(new base::MessageLoopForIO::FileDescriptorWatcher);
   StartWatchingDescriptor();
 }
 
 void LowMemoryObserverImpl::StopObservingOnFileThread() {
   // If StartObserving failed, StopObserving will still get called.
   timer_.Stop();
   if (file_descriptor_ >= 0) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
     watcher_.reset(NULL);
     ::close(file_descriptor_);
     file_descriptor_ = -1;
   }
 }
 
 void LowMemoryObserverImpl::ScheduleNextObservation() {
   timer_.Start(FROM_HERE,
                base::TimeDelta::FromMilliseconds(kLowMemoryCheckTimeoutMs),
                this,
                &LowMemoryObserverImpl::StartWatchingDescriptor);
 }
 
 void LowMemoryObserverImpl::StartWatchingDescriptor() {
   DCHECK(watcher_.get());
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
-  DCHECK(MessageLoopForIO::current());
+  DCHECK(base::MessageLoopForIO::current());
   if (file_descriptor_ < 0)
     return;
-  if (!MessageLoopForIO::current()->WatchFileDescriptor(
+  if (!base::MessageLoopForIO::current()->WatchFileDescriptor(
           file_descriptor_,
           false,  // persistent=false: We want it to fire once and reschedule.
-          MessageLoopForIO::WATCH_READ,
+          base::MessageLoopForIO::WATCH_READ,
           watcher_.get(),
           &watcher_delegate_)) {
     LOG(ERROR) << "Unable to watch " << kLowMemFile;
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // LowMemoryObserver
 
 LowMemoryObserver::LowMemoryObserver() : observer_(new LowMemoryObserverImpl) {}
@@ skipping 15 matching lines @@
       base::Bind(&LowMemoryObserverImpl::StopObservingOnFileThread,
                  observer_.get()));
 }
 
 // static
 void LowMemoryObserver::SetLowMemoryMargin(int64 margin_mb) {
   content::ZygoteHost::GetInstance()->AdjustLowMemoryMargin(margin_mb);
 }
 
 }  // namespace chromeos