Mojo: Refactor URLLoader interface.

mojo/shell/dynamic_service_loader.cc

 // Copyright 2014 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 "mojo/shell/dynamic_service_loader.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
@@ skipping 62 matching lines @@
         FROM_HERE,
         base::Bind(&Loader::StartService,
                    base::Unretained(this),
                    path,
                    base::Passed(&service_handle),
                    true));
   }
 };
 
 // For loading services via the network stack.
-class NetworkLoader : public Loader, public URLLoaderClient {
+class NetworkLoader : public Loader {
  public:
   explicit NetworkLoader(scoped_ptr<DynamicServiceRunner> runner,
                          NetworkService* network_service)
       : Loader(runner.Pass()) {
     network_service->CreateURLLoader(Get(&url_loader_));
-    url_loader_.set_client(this);
   }
 
   virtual void Start(const GURL& url,
                     ScopedMessagePipeHandle service_handle,
                     Context* context) OVERRIDE {
     service_handle_ = service_handle.Pass();
+    context_ = context;
 
     URLRequestPtr request(URLRequest::New());
     request->url = url.spec();
     request->auto_follow_redirects = true;
 
     if (base::CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kDisableCache)) {
       request->bypass_cache = true;
     }
 
-    DataPipe data_pipe;
-    url_loader_->Start(request.Pass(), data_pipe.producer_handle.Pass());
-
-    base::CreateTemporaryFile(&file_);
-    common::CopyToFile(data_pipe.consumer_handle.Pass(),
-                       file_,
-                       context->task_runners()->blocking_pool(),
-                       base::Bind(&Loader::StartService,
-                                  base::Unretained(this),
-                                  file_,
-                                  base::Passed(&service_handle_)));
+    url_loader_->Start(request.Pass(),
+                       base::Bind(&NetworkLoader::OnReceivedResponse,
+                                  base::Unretained(this)));
   }
 
  private:
   virtual ~NetworkLoader() {
     if (!file_.empty())
       base::DeleteFile(file_, false);
   }
 
-  // URLLoaderClient methods:
-  virtual void OnReceivedRedirect(URLResponsePtr response,
-                                  const String& new_url,
-                                  const String& new_method) OVERRIDE {
-    // TODO(darin): Handle redirects properly!
+  void OnReceivedResponse(URLResponsePtr response) {
+    if (response->error) {
+      LOG(ERROR) << "Error (" << response->error->code << ": "
+                 << response->error->description << ") while fetching "
+                 << response->url;
+    }
+
+    base::CreateTemporaryFile(&file_);
+    common::CopyToFile(response->body.Pass(),
+                       file_,
+                       context_->task_runners()->blocking_pool(),
+                       base::Bind(&Loader::StartService,
+                                  base::Unretained(this),
+                                  file_,
+                                  base::Passed(&service_handle_)));
   }
-  virtual void OnReceivedResponse(URLResponsePtr response) OVERRIDE {}
-  virtual void OnReceivedError(NetworkErrorPtr error) OVERRIDE {}
-  virtual void OnReceivedEndOfResponseBody() OVERRIDE {}
 
+  Context* context_;
   NetworkServicePtr network_service_;
   URLLoaderPtr url_loader_;
   ScopedMessagePipeHandle service_handle_;
   base::FilePath file_;
 };
 
 }  // namespace
 
 DynamicServiceLoader::DynamicServiceLoader(
     Context* context,
@@ skipping 32 matching lines @@
 }
 
 void DynamicServiceLoader::OnServiceError(ServiceManager* manager,
                                           const GURL& url) {
   // TODO(darin): What should we do about service errors? This implies that
   // the app closed its handle to the service manager. Maybe we don't care?
 }
 
 }  // namespace shell
 }  // namespace mojo