Move some misc thread-related stuff from base to base/thread and into the bas...

net/base/file_stream_posix.cc

 // 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.
 
 // For 64-bit file access (off_t = off64_t, lseek64, etc).
 #define _FILE_OFFSET_BITS 64
 
 #include "net/base/file_stream.h"
 
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <unistd.h>
 #include <errno.h>
 
 #include "base/basictypes.h"
 #include "base/callback.h"
 #include "base/eintr_wrapper.h"
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/string_util.h"
+#include "base/threading/worker_pool.h"
 #include "base/waitable_event.h"
-#include "base/worker_pool.h"
 #include "net/base/net_errors.h"
 
 // We cast back and forth, so make sure it's the size we're expecting.
 COMPILE_ASSERT(sizeof(int64) == sizeof(off_t), off_t_64_bit);
 
 // Make sure our Whence mappings match the system headers.
 COMPILE_ASSERT(net::FROM_BEGIN   == SEEK_SET &&
                net::FROM_CURRENT == SEEK_CUR &&
                net::FROM_END     == SEEK_END, whence_matches_system);
 
@@ skipping 207 matching lines @@
     }
   }
 }
 
 void FileStream::AsyncContext::InitiateAsyncRead(
     base::PlatformFile file, char* buf, int buf_len,
     CompletionCallback* callback) {
   DCHECK(!callback_);
   callback_ = callback;
 
-  WorkerPool::PostTask(FROM_HERE,
-                       new BackgroundReadTask(
-                           file, buf, buf_len,
-                           &background_io_completed_callback_),
-                       true /* task_is_slow */);
+  base::WorkerPool::PostTask(FROM_HERE,
+                             new BackgroundReadTask(
+                                 file, buf, buf_len,
+                                 &background_io_completed_callback_),
+                             true /* task_is_slow */);
 }
 
 void FileStream::AsyncContext::InitiateAsyncWrite(
     base::PlatformFile file, const char* buf, int buf_len,
     CompletionCallback* callback) {
   DCHECK(!callback_);
   callback_ = callback;
 
-  WorkerPool::PostTask(FROM_HERE,
-                       new BackgroundWriteTask(
-                           file, buf, buf_len,
-                           &background_io_completed_callback_),
-                       true /* task_is_slow */);
+  base::WorkerPool::PostTask(FROM_HERE,
+                             new BackgroundWriteTask(
+                                 file, buf, buf_len,
+                                 &background_io_completed_callback_),
+                             true /* task_is_slow */);
 }
 
 void FileStream::AsyncContext::OnBackgroundIOCompleted(int result) {
   result_ = result;
   message_loop_task_ = new CancelableCallbackTask(
       NewCallback(this, &AsyncContext::RunAsynchronousCallback));
   message_loop_->PostTask(FROM_HERE, message_loop_task_);
   background_io_completed_.Signal();
 }
 
@@ skipping 191 matching lines @@
   int64 seek_position = Seek(FROM_BEGIN, bytes);
   if (seek_position != bytes)
     return ERR_UNEXPECTED;
 
   // And truncate the file.
   int result = ftruncate(file_, bytes);
   return result == 0 ? seek_position : MapErrorCode(errno);
 }
 
 }  // namespace net