net: Implement canceling of all async operations in FileStream.

chrome/browser/bookmarks/bookmark_html_writer.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/bookmarks/bookmark_html_writer.h"
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
@@ skipping 79 matching lines @@
 // Class responsible for the actual writing. Takes ownership of favicons_map.
 class Writer : public base::RefCountedThreadSafe<Writer> {
  public:
   Writer(base::Value* bookmarks,
          const FilePath& path,
          BookmarkFaviconFetcher::URLFaviconMap* favicons_map,
          BookmarksExportObserver* observer)
       : bookmarks_(bookmarks),
         path_(path),
         favicons_map_(favicons_map),
-        observer_(observer),
-        file_stream_(NULL) {
+        observer_(observer) {
   }
 
   // Writing bookmarks and favicons data to file.
   void DoWrite() {
     if (!OpenFile())
       return;
 
     Value* roots = NULL;
     if (!Write(kHeader) ||
         bookmarks_->GetType() != Value::TYPE_DICTIONARY ||
@@ skipping 30 matching lines @@
         !WriteNode(*static_cast<DictionaryValue*>(mobile_folder_value),
                    BookmarkNode::MOBILE)) {
       return;
     }
 
     DecrementIndent();
 
     Write(kFolderChildrenEnd);
     Write(kNewline);
     // File stream close is forced so that unit test could read it.
-    file_stream_.CloseSync();
+    file_stream_.reset();
 
     NotifyOnFinish();
   }
 
  private:
   friend class base::RefCountedThreadSafe<Writer>;
 
   // Types of text being written out. The type dictates how the text is
   // escaped.
   enum TextType {
     // The text is the value of an html attribute, eg foo in
     // <a href="foo">.
     ATTRIBUTE_VALUE,
 
     // Actual content, eg foo in <h1>foo</h2>.
     CONTENT
   };
 
   ~Writer() {}
 
   // Opens the file, returning true on success.
   bool OpenFile() {
+    file_stream_.reset(new net::FileStream(NULL));
     int flags = base::PLATFORM_FILE_CREATE_ALWAYS | base::PLATFORM_FILE_WRITE;
-    return (file_stream_.OpenSync(path_, flags) == net::OK);
+    return (file_stream_->OpenSync(path_, flags) == net::OK);
   }
 
   // Increments the indent.
   void IncrementIndent() {
     indent_.resize(indent_.size() + kIndentSize, ' ');
   }
 
   // Decrements the indent.
   void DecrementIndent() {
     DCHECK(!indent_.empty());
     indent_.resize(indent_.size() - kIndentSize, ' ');
   }
 
   // Called at the end of the export process.
   void NotifyOnFinish() {
     if (observer_ != NULL) {
       observer_->OnExportFinished();
     }
   }
 
   // Writes raw text out returning true on success. This does not escape
   // the text in anyway.
   bool Write(const std::string& text) {
-    size_t wrote = file_stream_.WriteSync(text.c_str(), text.length());
+    size_t wrote = file_stream_->WriteSync(text.c_str(), text.length());
     bool result = (wrote == text.length());
     DCHECK(result);
     return result;
   }
 
   // Writes out the text string (as UTF8). The text is escaped based on
   // type.
   bool Write(const std::string& text, TextType type) {
     DCHECK(IsStringUTF8(text));
     std::string utf8_string;
@@ skipping 156 matching lines @@
   // Path we're writing to.
   FilePath path_;
 
   // Map that stores favicon per URL.
   scoped_ptr<BookmarkFaviconFetcher::URLFaviconMap> favicons_map_;
 
   // Observer to be notified on finish.
   BookmarksExportObserver* observer_;
 
   // File we're writing to.
-  net::FileStream file_stream_;
+  scoped_ptr<net::FileStream> file_stream_;
 
   // How much we indent when writing a bookmark/folder. This is modified
   // via IncrementIndent and DecrementIndent.
   std::string indent_;
 
   DISALLOW_COPY_AND_ASSIGN(Writer);
 };
 
 }  // namespace
 
@@ skipping 114 matching lines @@
   // BookmarkModel isn't thread safe (nor would we want to lock it down
   // for the duration of the write), as such we make a copy of the
   // BookmarkModel using BookmarkCodec then write from that.
   if (fetcher == NULL) {
     fetcher = new BookmarkFaviconFetcher(profile, path, observer);
     fetcher->ExportBookmarks();
   }
 }
 
 }  // namespace bookmark_html_writer