net: Implement canceling of all async operations in FileStream.

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 281 matching lines @@
 // Cancel methods are proxied over to the IO thread, where an net::URLRequest
 // object is instantiated.
 struct DeleteOnIOThread;  // See below.
 class RequestProxy
     : public net::URLRequest::Delegate,
       public base::RefCountedThreadSafe<RequestProxy, DeleteOnIOThread> {
  public:
   // Takes ownership of the params.
   RequestProxy()
       : download_to_file_(false),
-        file_stream_(NULL),
         buf_(new net::IOBuffer(kDataSize)),
         last_upload_position_(0) {
   }
 
   void DropPeer() {
     peer_ = NULL;
   }
 
   void Start(ResourceLoaderBridge::Peer* peer, RequestParams* params) {
     peer_ = peer;
@@ skipping 124 matching lines @@
     SimpleAppCacheSystem::SetExtraRequestInfo(
         request_.get(), params->appcache_host_id, params->request_type);
 
     download_to_file_ = params->download_to_file;
     if (download_to_file_) {
       FilePath path;
       if (file_util::CreateTemporaryFile(&path)) {
         downloaded_file_ = ShareableFileReference::GetOrCreate(
             path, ShareableFileReference::DELETE_ON_FINAL_RELEASE,
             base::MessageLoopProxy::current());
-        file_stream_.OpenSync(
+        file_stream_.reset(new net::FileStream(NULL));
+        file_stream_->OpenSync(
             path, base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_WRITE);
       }
     }
 
     request_->Start();
 
     if (request_->has_upload() &&
         params->load_flags & net::LOAD_ENABLE_UPLOAD_PROGRESS) {
       upload_progress_timer_.Start(FROM_HERE,
           base::TimeDelta::FromMilliseconds(kUpdateUploadProgressIntervalMsec),
@@ skipping 57 matching lines @@
 
   virtual void OnReceivedResponse(
       const ResourceResponseInfo& info) {
     owner_loop_->PostTask(
         FROM_HERE,
         base::Bind(&RequestProxy::NotifyReceivedResponse, this, info));
   }
 
   virtual void OnReceivedData(int bytes_read) {
     if (download_to_file_) {
-      file_stream_.WriteSync(buf_->data(), bytes_read);
+      file_stream_->WriteSync(buf_->data(), bytes_read);
       owner_loop_->PostTask(
           FROM_HERE,
           base::Bind(&RequestProxy::NotifyDownloadedData, this, bytes_read));
       return;
     }
 
     owner_loop_->PostTask(
         FROM_HERE,
         base::Bind(&RequestProxy::NotifyReceivedData, this, bytes_read));
   }
 
   virtual void OnCompletedRequest(int error_code,
                                   const std::string& security_info,
                                   const base::TimeTicks& complete_time) {
     if (download_to_file_)
-      file_stream_.CloseSync();
+      file_stream_.reset();
     owner_loop_->PostTask(
         FROM_HERE,
         base::Bind(&RequestProxy::NotifyCompletedRequest, this, error_code,
                    security_info, complete_time));
   }
 
   // --------------------------------------------------------------------------
   // net::URLRequest::Delegate implementation:
 
   virtual void OnReceivedRedirect(net::URLRequest* request,
@@ skipping 184 matching lines @@
                                       net::ERR_ACCESS_DENIED));
       }
     }
     return true;
   }
 
   scoped_ptr<net::URLRequest> request_;
 
   // Support for request.download_to_file behavior.
   bool download_to_file_;
-  net::FileStream file_stream_;
+  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_;
 
@@ skipping 55 matching lines @@
     }
     result_->url = new_url;
   }
 
   virtual void OnReceivedResponse(const ResourceResponseInfo& info) OVERRIDE {
     *static_cast<ResourceResponseInfo*>(result_) = info;
   }
 
   virtual void OnReceivedData(int bytes_read) OVERRIDE {
     if (download_to_file_)
-      file_stream_.WriteSync(buf_->data(), bytes_read);
+      file_stream_->WriteSync(buf_->data(), bytes_read);
     else
       result_->data.append(buf_->data(), bytes_read);
     AsyncReadData();  // read more (may recurse)
   }
 
   virtual void OnCompletedRequest(
       int error_code,
       const std::string& security_info,
       const base::TimeTicks& complete_time) OVERRIDE {
     if (download_to_file_)
-      file_stream_.CloseSync();
+      file_stream_.reset();
     result_->error_code = error_code;
     event_.Signal();
   }
 
  protected:
   virtual ~SyncRequestProxy() {}
 
  private:
   ResourceLoaderBridge::SyncLoadResponse* result_;
   base::WaitableEvent event_;
@@ skipping 263 matching lines @@
          (http_prefix.SchemeIs("http") || http_prefix.SchemeIs("https")));
   g_file_over_http_params = new FileOverHTTPParams(file_path_template,
                                                    http_prefix);
 }
 
 // static
 webkit_glue::ResourceLoaderBridge* SimpleResourceLoaderBridge::Create(
     const webkit_glue::ResourceLoaderBridge::RequestInfo& request_info) {
   return new ResourceLoaderBridgeImpl(request_info);
 }