Move ProxyResolutionServiceProvider to chromeos/dbus/services

chromeos/dbus/services/proxy_resolution_service_provider.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/dbus/proxy_resolution_service_provider.h"
+#include "chromeos/dbus/services/proxy_resolution_service_provider.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/thread_task_runner_handle.h"
-#include "chrome/browser/profiles/profile_manager.h"
 #include "dbus/bus.h"
+#include "dbus/exported_object.h"
 #include "dbus/message.h"
-#include "dbus/exported_object.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/proxy/proxy_service.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace chromeos {
 
 // The ProxyResolverInterface implementation used in production.
@@ skipping 20 matching lines @@
 
     std::string source_url_;  // URL being resolved.
     net::ProxyInfo proxy_info_;  // ProxyInfo resolved for source_url_.
     std::string error_;  // Error from proxy resolution.
     base::Closure notify_task_;  // Task to notify of resolution result.
 
    private:
     DISALLOW_COPY_AND_ASSIGN(Request);
   };
 
-  ProxyResolverImpl() : origin_thread_(base::ThreadTaskRunnerHandle::Get()),
-                        weak_ptr_factory_(this) {
+  explicit ProxyResolverImpl(scoped_ptr<ProxyResolverDelegate> delegate)
+      : delegate_(delegate.Pass()),
+        origin_thread_(base::ThreadTaskRunnerHandle::Get()),
+        weak_ptr_factory_(this) {
   }
 
   virtual ~ProxyResolverImpl() {
     DCHECK(OnOriginThread());
 
     for (std::set<Request*>::iterator iter = all_requests_.begin();
          iter != all_requests_.end(); ++iter) {
       Request* request = *iter;
       LOG(WARNING) << "Pending request for " << request->source_url_;
       delete request;
@@ skipping 12 matching lines @@
     Request* request = new Request(source_url);
     request->notify_task_ = base::Bind(
         &ProxyResolverImpl::NotifyProxyResolved,
         weak_ptr_factory_.GetWeakPtr(),
         signal_interface,
         signal_name,
         exported_object,
         request);
     all_requests_.insert(request);
 
-    // GetPrimaryUserProfile() and GetRequestContext() must be called on UI
-    // thread.
-    Profile* profile = ProfileManager::GetPrimaryUserProfile();
+    // GetRequestContext() must be called on UI thread.
     scoped_refptr<net::URLRequestContextGetter> getter =
-        profile->GetRequestContext();
+        delegate_->GetRequestContext();
 
     getter->GetNetworkTaskRunner()->PostTask(
         FROM_HERE,
         base::Bind(&ProxyResolverImpl::ResolveProxyInternal,
                    request,
                    origin_thread_,
                    getter,
                    exported_object));
   }
 
@@ skipping 64 matching lines @@
       all_requests_.erase(iter);
     }
     delete request;
   }
 
   // Returns true if the current thread is on the origin thread.
   bool OnOriginThread() {
     return origin_thread_->BelongsToCurrentThread();
   }
 
+  scoped_ptr<ProxyResolverDelegate> delegate_;
   scoped_refptr<base::SingleThreadTaskRunner> origin_thread_;
   std::set<Request*> all_requests_;
   base::WeakPtrFactory<ProxyResolverImpl> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ProxyResolverImpl);
 };
 
 ProxyResolutionServiceProvider::ProxyResolutionServiceProvider(
     ProxyResolverInterface* resolver)
     : resolver_(resolver),
@@ skipping 70 matching lines @@
     dbus::MethodCall* method_call,
     dbus::ExportedObject::ResponseSender response_sender) {
   if (!provider_weak_ptr) {
     LOG(WARNING) << "Called after the object is deleted";
     response_sender.Run(scoped_ptr<dbus::Response>());
     return;
   }
   provider_weak_ptr->ResolveProxyHandler(method_call, response_sender);
 }
 
-ProxyResolutionServiceProvider* ProxyResolutionServiceProvider::Create() {
-  return new ProxyResolutionServiceProvider(new ProxyResolverImpl);
+ProxyResolutionServiceProvider* ProxyResolutionServiceProvider::Create(
+    scoped_ptr<ProxyResolverDelegate> delegate) {
+  return new ProxyResolutionServiceProvider(
+      new ProxyResolverImpl(delegate.Pass()));
 }
 
 ProxyResolutionServiceProvider*
 ProxyResolutionServiceProvider::CreateForTesting(
     ProxyResolverInterface* resolver) {
   return new ProxyResolutionServiceProvider(resolver);
 }
 
 ProxyResolverInterface::~ProxyResolverInterface() {
 }
 
 }  // namespace chromeos