Delete the temporary file when generating MHTML with the extension API.

chrome/browser/extensions/extension_function.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 CHROME_BROWSER_EXTENSIONS_EXTENSION_FUNCTION_H_
 #define CHROME_BROWSER_EXTENSIONS_EXTENSION_FUNCTION_H_
 #pragma once
 
 #include <list>
 #include <string>
 
 #include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/process.h"
 #include "chrome/browser/extensions/extension_info_map.h"
 #include "chrome/common/extensions/extension.h"
+#include "content/browser/renderer_host/render_view_host_observer.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "ipc/ipc_message.h"
 
 class Browser;
 class ChromeRenderMessageFilter;
 class ExtensionFunction;
 class ExtensionFunctionDispatcher;
 class UIThreadExtensionFunction;
@@ skipping 176 matching lines @@
 };
 
 // Extension functions that run on the UI thread. Most functions fall into
 // this category.
 class UIThreadExtensionFunction : public ExtensionFunction {
  public:
   UIThreadExtensionFunction();
 
   virtual UIThreadExtensionFunction* AsUIThreadExtensionFunction() OVERRIDE;
 
+  // Called when a message was received.
+  // Should return true if it processed the message.
+  virtual bool OnMessageReceivedFromRenderView(const IPC::Message& message);
+
   // Set the profile which contains the extension that has originated this
   // function call.
   void set_profile(Profile* profile) { profile_ = profile; }
   Profile* profile() const { return profile_; }
 
   void SetRenderViewHost(RenderViewHost* render_view_host);
   RenderViewHost* render_view_host() const { return render_view_host_; }
 
   void set_dispatcher(
       const base::WeakPtr<ExtensionFunctionDispatcher>& dispatcher) {
@@ skipping 50 matching lines @@
    public:
     explicit RenderViewHostTracker(UIThreadExtensionFunction* function);
    private:
     virtual void Observe(int type,
                          const content::NotificationSource& source,
                          const content::NotificationDetails& details) OVERRIDE;
     UIThreadExtensionFunction* function_;
     content::NotificationRegistrar registrar_;
   };
 
+  class ExtensionRenderViewHostObserver : public RenderViewHostObserver {

[Mihai Parparita -not on Chrome, 2011/11/15 18:51:42]

Does this have to live in ExtensionUIFunction (instead of just in your function
subclass)? UpdateTabFunction was able to use TabContentsObserver directly.

[asargent_no_longer_on_chrome, 2011/11/15 18:56:31]

We already have the RenderViewHostTracker class defined above for watching the
lifetime of RVH's. Did you consider just adding this functionality to that
class? 

[Jay Civelli, 2011/11/18 23:14:32]

My case is actually different. The TabContentsObserver won't receive that
message, because it is coming from the extension popup render view, not the tab
contents ( ExecuteCodeInTabFunction and UpdateTabFunction talk to the tab's
render view). That's why I have to listen directly at the RenderViewHost level.

[Jay Civelli, 2011/11/18 23:14:32]

Good idea, done.

+   public:
+    ExtensionRenderViewHostObserver(UIThreadExtensionFunction* function,
+                                    RenderViewHost* render_view_host);
+
+   private:
+    virtual void RenderViewHostDestroyed(
+        RenderViewHost* render_view_host) OVERRIDE;
+    virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
+
+    UIThreadExtensionFunction* function_;
+
+    DISALLOW_COPY_AND_ASSIGN(ExtensionRenderViewHostObserver);
+  };
+
   virtual void Destruct() const;
 
   scoped_ptr<RenderViewHostTracker> tracker_;
+  scoped_ptr<ExtensionRenderViewHostObserver> render_view_host_observer_;
 };
 
 // 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 69 matching lines @@
  public:
   SyncIOThreadExtensionFunction();
 
   virtual void Run() OVERRIDE;
 
  protected:
   virtual ~SyncIOThreadExtensionFunction();
 };
 
 #endif  // CHROME_BROWSER_EXTENSIONS_EXTENSION_FUNCTION_H_