Update implementation following changes to URLRequest cache mode.

mojo/services/network/url_loader_impl.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/services/network/url_loader_impl.h"
 
 #include <memory>
 
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 76 matching lines @@
   }
 
  private:
   ScopedDataPipeConsumerHandle pipe_;
   uint32_t num_bytes_;
   uint32_t offset_;
 
   DISALLOW_COPY_AND_ASSIGN(UploadDataPipeElementReader);
 };
 
+bool IsValidCacheMode(int cache_mode) {
+  switch (cache_mode) {
+    case URLRequest::CACHE_MODE_DEFAULT:
+    case URLRequest::CACHE_MODE_BYPASS_CACHE:
+    case URLRequest::CACHE_MODE_ONLY_FROM_CACHE:
+      return true;
+  }
+  return false;
+}
+
 }  // namespace
 
 // Each body fetcher takes ownership of a net::URLRequest and stream its data
 // to a data pipe. It is owned by an URLLoaderImpl and will notify its owner
 // when either the data pipe is closed or the request is finished.
 class URLLoaderImpl::BodyFetcher : public net::URLRequest::Delegate {
  public:
   BodyFetcher(URLLoaderImpl* loader,
               uint32_t id,
               scoped_ptr<net::URLRequest> url_request,
@@ skipping 381 matching lines @@
   interceptor_index_ = 0;
   redirect_info_.reset();
   // TODO(darin): Verify that it makes sense to call FollowDeferredRedirect.
   url_request_->FollowDeferredRedirect();
 }
 
 void URLLoaderImpl::StartInternal(URLRequestPtr request) {
   DCHECK(!url_request_);
   DCHECK(!redirect_info_);
 
+  if (!IsValidCacheMode(request->cache_mode)) {
+    // Unknown cache mode. The request must fail.
+    delete this;
+    return;
+  }
+
   if (interceptor_index_ >= 0 &&
       interceptor_index_ < static_cast<int>(interceptors_.size())) {
     interceptors_[interceptor_index_]->InterceptRequest(
         request.Pass(), base::Bind(&URLLoaderImpl::OnIntercept,
                                    base::Unretained(this)));
     return;
   }
 
   DCHECK(interceptor_index_ == -1);
   interceptor_index_ = 0;
@@ skipping 22 matching lines @@
   if (request->body) {
     ScopedVector<net::UploadElementReader> element_readers;
     for (size_t i = 0; i < request->body.size(); ++i) {
       element_readers.push_back(
           new UploadDataPipeElementReader(request->body[i].Pass()));
     }
     url_request_->set_upload(make_scoped_ptr<net::UploadDataStream>(
         new net::ElementsUploadDataStream(element_readers.Pass(), 0)));
   }
   int load_flags = 0;
-  if (request->bypass_cache)
-    load_flags |= net::LOAD_BYPASS_CACHE;
-  if (request->only_from_cache)
-    load_flags |= net::LOAD_ONLY_FROM_CACHE;
+  switch (request->cache_mode) {
+    case URLRequest::CACHE_MODE_DEFAULT:
+      break;
+    case URLRequest::CACHE_MODE_BYPASS_CACHE:
+      load_flags |= net::LOAD_BYPASS_CACHE;
+    case URLRequest::CACHE_MODE_ONLY_FROM_CACHE:
+      load_flags |= net::LOAD_ONLY_FROM_CACHE;
+      break;
+  }
   if (load_flags)
     url_request_->SetLoadFlags(load_flags);
 
   response_body_buffer_size_ = request->response_body_buffer_size;
   auto_follow_redirects_ = request->auto_follow_redirects;
 
   url_request_->Start();
 }
 
 void URLLoaderImpl::SendResponse(URLResponsePtr response) {
@@ skipping 22 matching lines @@
   if ((*it)->id() == current_fetcher_id_) {
     last_status_ = fetcher->QueryStatus();
     last_status_->is_loading = false;
   }
   body_fetchers_.erase(it);
   if (body_fetchers_.empty() and !binding_.is_bound())
     delete this;
 }
 
 }  // namespace mojo