PPAPI: Force async callback invocation option.

ppapi/cpp/completion_callback.h

 // Copyright (c) 2011 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.
 
 #ifndef PPAPI_CPP_COMPLETION_CALLBACK_H_
 #define PPAPI_CPP_COMPLETION_CALLBACK_H_
 
 #include "ppapi/c/pp_completion_callback.h"
 #include "ppapi/cpp/logging.h"
 #include "ppapi/cpp/non_thread_safe_ref_count.h"
 
 namespace pp {
 
 // A CompletionCallback provides a wrapper around PP_CompletionCallback.
 class CompletionCallback {
  public:
   // Use this special constructor to create a 'blocking' CompletionCallback
   // that may be passed to a method to indicate that the calling thread should
   // be blocked until the asynchronous operation corresponding to the method
   // completes.
   struct Block {};
   CompletionCallback(Block) {
     cc_ = PP_BlockUntilComplete();
   }
 
   CompletionCallback(PP_CompletionCallback_Func func, void* user_data) {
     cc_ = PP_MakeCompletionCallback(func, user_data);
   }
 
+  void set_flags(int32_t flags) { cc_.flags = flags; }
+
   // Call this method to explicitly run the CompletionCallback.  Normally, the
   // system runs a CompletionCallback after an asynchronous operation
   // completes, but programs may wish to run the CompletionCallback manually
   // in order to reuse the same code paths.
   void Run(int32_t result) {
     PP_DCHECK(cc_.func);
     PP_RunCompletionCallback(&cc_, result);
   }
 
   const PP_CompletionCallback& pp_completion_callback() const { return cc_; }
@@ skipping 22 matching lines @@
 // EXAMPLE USAGE:
 //
 //   class MyHandler {
 //    public:
 //     MyHandler() : factory_(this), offset_(0) {
 //     }
 //
 //     void ProcessFile(const FileRef& file) {
 //       CompletionCallback cc = factory_.NewCallback(&MyHandler::DidOpen);
 //       int32_t rv = fio_.Open(file, PP_FileOpenFlag_Read, cc);
-//       if (rv != PP_OK_COMPLETIONPENDING)
-//         cc.Run(rv);
+//       CHECK(rv == PP_OK_COMPLETIONPENDING);
 //     }
 //
 //    private:
 //     CompletionCallback NewCallback() {
 //       return factory_.NewCallback(&MyHandler::DidCompleteIO);
 //     }
 //
 //     void DidOpen(int32_t result) {
 //       if (result == PP_OK) {
 //         // The file is open, and we can begin reading.
@@ skipping 10 matching lines @@
 //         ProcessBytes(buf_, result);
 //         offset_ += result;
 //         ReadMore();
 //       } else {
 //         // Done reading (possibly with an error given by 'result').
 //       }
 //     }
 //
 //     void ReadMore() {
 //       CompletionCallback cc = factory_.NewCallback(&MyHandler::DidRead);
+//       cc.set_flags(PP_COMPLETIONCALLBACK_FLAG_NOFORCEASYNC);
 //       int32_t rv = fio_.Read(offset_, buf_, sizeof(buf_),
 //                              cc.pp_completion_callback());
 //       if (rv != PP_OK_COMPLETIONPENDING)
 //         cc.Run(rv);
 //     }
 //
 //     void ProcessBytes(const char* bytes, int32_t length) {
 //       // Do work ...
 //     }
 //
@@ skipping 191 matching lines @@
   CompletionCallbackFactory(const CompletionCallbackFactory&);
   CompletionCallbackFactory& operator=(const CompletionCallbackFactory&);
 
   T* object_;
   BackPointer* back_pointer_;
 };
 
 }  // namespace pp
 
 #endif  // PPAPI_CPP_COMPLETION_CALLBACK_H_