Blobs: Catching browser-process created Blobs in extension code.

extensions/browser/extension_function.h

 // Copyright 2013 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 EXTENSIONS_BROWSER_EXTENSION_FUNCTION_H_
 #define EXTENSIONS_BROWSER_EXTENSION_FUNCTION_H_
 
 #include <list>
 #include <string>
 
@@ skipping 26 matching lines @@
 class RenderViewHost;
 class WebContents;
 }
 
 namespace extensions {
 class ExtensionFunctionDispatcher;
 class ExtensionMessageFilter;
 class QuotaLimitHeuristic;
 }
 
+namespace IPC {
+class Sender;
+}
+
 #ifdef NDEBUG
 #define EXTENSION_FUNCTION_VALIDATE(test) \
   do {                                    \
     if (!(test)) {                        \
       bad_message_ = true;                \
       return ValidationFailure(this);     \
     }                                     \
   } while (0)
 #else   // NDEBUG
 #define EXTENSION_FUNCTION_VALIDATE(test) CHECK(test)
@@ skipping 364 matching lines @@
                       const std::string& message);
 
   friend struct content::BrowserThread::DeleteOnThread<
       content::BrowserThread::UI>;
   friend class base::DeleteHelper<UIThreadExtensionFunction>;
 
   virtual ~UIThreadExtensionFunction();
 
   virtual void SendResponse(bool success) OVERRIDE;
 
+  // Sets the Blob UUIDs whose ownership is being transferred to the renderer.
+  void SetTransferredBlobUUIDs(const std::vector<std::string>& blob_uuids);
+
   // The dispatcher that will service this extension function call.
   base::WeakPtr<extensions::ExtensionFunctionDispatcher> dispatcher_;
 
   // The RenderViewHost we will send responses to.
   content::RenderViewHost* render_view_host_;
 
   // The RenderFrameHost we will send responses to.
   // NOTE: either render_view_host_ or render_frame_host_ will be set, as we
   // port code to use RenderFrames for OOPIF. See http://crbug.com/304341.
   content::RenderFrameHost* render_frame_host_;
 
   // The content::BrowserContext of this function's extension.
   content::BrowserContext* context_;
 
  private:
   class RenderHostTracker;
 
   virtual void Destruct() const OVERRIDE;
 
+  // TODO(tommycli): Remove once RenderViewHost is gone.
+  IPC::Sender* GetIPCSender();
+  int GetRoutingID();
+
   scoped_ptr<RenderHostTracker> tracker_;
 
   DelegateForTests* delegate_;
+
+  // The blobs transferred to the renderer process.
+  std::vector<std::string> transferred_blob_uuids_;
 };
 
 // Extension functions that run on the IO thread. This type of function avoids
 // a roundtrip to and from the UI thread (because communication with the
 // extension process happens on the IO thread). It's intended to be used when
 // performance is critical (e.g. the webRequest API which can block network
 // requests). Generally, UIThreadExtensionFunction is more appropriate and will
 // be easier to use and interface with the rest of the browser.
 class IOThreadExtensionFunction : public ExtensionFunction {
  public:
@@ skipping 104 matching lines @@
   virtual bool RunSync() = 0;
 
   // ValidationFailure override to match RunSync().
   static bool ValidationFailure(SyncIOThreadExtensionFunction* function);
 
  private:
   virtual ResponseAction Run() OVERRIDE;
 };
 
 #endif  // EXTENSIONS_BROWSER_EXTENSION_FUNCTION_H_