webkit: Use base::MessageLoop.

webkit/tools/test_shell/simple_resource_loader_bridge.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.
 //
 // This file contains an implementation of the ResourceLoaderBridge class.
 // The class is implemented using net::URLRequest, meaning it is a "simple"
 // version that directly issues requests. The more complicated one used in the
 // browser uses IPC.
 //
 // Because net::URLRequest only provides an asynchronous resource loading API,
@@ skipping 325 matching lines @@
         buf_(new net::IOBuffer(kDataSize)),
         last_upload_position_(0) {
   }
 
   void DropPeer() {
     peer_ = NULL;
   }
 
   void Start(ResourceLoaderBridge::Peer* peer, RequestParams* params) {
     peer_ = peer;
-    owner_loop_ = MessageLoop::current();
+    owner_loop_ = base::MessageLoop::current();
 
     ConvertRequestParamsForFileOverHTTPIfNeeded(params);
     // proxy over to the io thread
     g_io_thread->message_loop()->PostTask(
         FROM_HERE,
         base::Bind(&RequestProxy::AsyncStart, this, params));
   }
 
   void Cancel() {
     // proxy over to the io thread
     g_io_thread->message_loop()->PostTask(
         FROM_HERE,
         base::Bind(&RequestProxy::AsyncCancel, this));
   }
 
  protected:
   friend class base::DeleteHelper<RequestProxy>;
   friend class base::RefCountedThreadSafe<RequestProxy>;
   friend struct DeleteOnIOThread;
 
   virtual ~RequestProxy() {
     // Ensure we are deleted on the IO thread because base::Timer requires that.
     // (guaranteed by the Traits class template parameter).
-    DCHECK(MessageLoop::current() == g_io_thread->message_loop());
+    DCHECK(base::MessageLoop::current() == g_io_thread->message_loop());
   }
 
   // --------------------------------------------------------------------------
   // The following methods are called on the owner's thread in response to
   // various net::URLRequest callbacks.  The event hooks, defined below, trigger
   // these methods asynchronously.
 
   void NotifyReceivedRedirect(const GURL& new_url,
                               const ResourceResponseInfo& info) {
     bool has_new_first_party_for_cookies = false;
@@ skipping 411 matching lines @@
   bool download_to_file_;
   scoped_ptr<net::FileStream> file_stream_;
   scoped_refptr<ShareableFileReference> downloaded_file_;
 
   // Size of our async IO data buffers
   static const int kDataSize = 16*1024;
 
   // read buffer for async IO
   scoped_refptr<net::IOBuffer> buf_;
 
-  MessageLoop* owner_loop_;
+  base::MessageLoop* owner_loop_;
 
   // This is our peer in WebKit (implemented as ResourceHandleInternal). We do
   // not manage its lifetime, and we may only access it from the owner's
   // message loop (owner_loop_).
   ResourceLoaderBridge::Peer* peer_;
 
   // Timer used to pull upload progress info.
   base::RepeatingTimer<RequestProxy> upload_progress_timer_;
 
   // Info used to determine whether or not to send an upload progress update.
   uint64 last_upload_position_;
   base::TimeTicks last_upload_ticks_;
 
   // Save the real FILE URL prefix for the FILE URL which converts to HTTP URL.
   std::string file_url_prefix_;
   // Save a failed file request status to pass it to webkit.
   scoped_ptr<net::URLRequestStatus> failed_file_request_status_;
 };
 
 // Helper guaranteeing deletion on the IO thread (like
 // content::BrowserThread::DeleteOnIOThread, but without the dependency).
 struct DeleteOnIOThread {
   static void Destruct(const RequestProxy* obj) {
-    if (MessageLoop::current() == g_io_thread->message_loop())
+    if (base::MessageLoop::current() == g_io_thread->message_loop())
       delete obj;
     else
       g_io_thread->message_loop()->DeleteSoon(FROM_HERE, obj);
   }
 };
 
 //-----------------------------------------------------------------------------
 
 class SyncRequestProxy : public RequestProxy {
  public:
@@ skipping 141 matching lines @@
   // The request proxy is allocated when we start the request, and then it
   // sticks around until this ResourceLoaderBridge is destroyed.
   RequestProxy* proxy_;
 };
 
 //-----------------------------------------------------------------------------
 
 class CookieSetter : public base::RefCountedThreadSafe<CookieSetter> {
  public:
   void Set(const GURL& url, const std::string& cookie) {
-    DCHECK(MessageLoop::current() == g_io_thread->message_loop());
-    g_request_context->cookie_store()->SetCookieWithOptionsAsync(
-        url, cookie, net::CookieOptions(),
-        net::CookieStore::SetCookiesCallback());
+    DCHECK(base::MessageLoop::current() == g_io_thread->message_loop());
+    g_request_context->cookie_store()
+        ->SetCookieWithOptionsAsync(url,

[brettw, 2013/05/06 17:43:33]

You didn't need to change this and I think the old way was better.

[xhwang, 2013/05/07 00:11:07]

Done.

[xhwang, 2013/05/07 00:11:07]

Done.

+                                    cookie,
+                                    net::CookieOptions(),
+                                    net::CookieStore::SetCookiesCallback());
   }
 
  private:
   friend class base::RefCountedThreadSafe<CookieSetter>;
   ~CookieSetter() {}
 };
 
 class CookieGetter : public base::RefCountedThreadSafe<CookieGetter> {
  public:
   CookieGetter() : event_(false, false) {
@@ skipping 110 matching lines @@
 #if defined(OS_MACOSX) || defined(OS_WIN)
   // We want to be sure to init NSPR on the main thread.
   crypto::EnsureNSPRInit();
 #endif
 
   // Create the cache thread. We want the cache thread to outlive the IO thread,
   // so its lifetime is bonded to the IO thread lifetime.
   DCHECK(!g_cache_thread);
   g_cache_thread = new base::Thread("cache");
   CHECK(g_cache_thread->StartWithOptions(
-      base::Thread::Options(MessageLoop::TYPE_IO, 0)));
+      base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
 
   g_io_thread = new IOThread();
   base::Thread::Options options;
-  options.message_loop_type = MessageLoop::TYPE_IO;
+  options.message_loop_type = base::MessageLoop::TYPE_IO;
   return g_io_thread->StartWithOptions(options);
 }
 
 // static
 void SimpleResourceLoaderBridge::SetAcceptAllCookies(bool accept_all_cookies) {
   g_accept_all_cookies = accept_all_cookies;
 }
 
 // static
 scoped_refptr<base::MessageLoopProxy>
@@ skipping 20 matching lines @@
   if (!g_file_over_http_mappings)
     g_file_over_http_mappings = new FileOverHTTPPathMappings();
   g_file_over_http_mappings->AddMapping(file_path_template, http_prefix);
 }
 
 // static
 webkit_glue::ResourceLoaderBridge* SimpleResourceLoaderBridge::Create(
     const webkit_glue::ResourceLoaderBridge::RequestInfo& request_info) {
   return new ResourceLoaderBridgeImpl(request_info);
 }