Make sure PluginDataRemoverImpl::Init is executed after the constructor has finished.

content/browser/plugin_data_remover_impl.cc

 // 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.
 
 #include "content/browser/plugin_data_remover_impl.h"
 
 #include "base/bind.h"
 #include "base/metrics/histogram.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/version.h"
@@ skipping 42 matching lines @@
   if (rv)
     *plugin = *plugin_it;
   return rv;
 }
 
 }
 
 class PluginDataRemoverImpl::Context
     : public PluginProcessHost::Client,
       public IPC::Channel::Listener,
-      public base::RefCountedThreadSafe<Context> {
+      public base::RefCountedThreadSafe<Context,
+                                        BrowserThread::DeleteOnIOThread> {
  public:
-  Context(const std::string& mime_type,
-          base::Time begin_time,
+  Context(base::Time begin_time,
           const content::ResourceContext& resource_context)
       : event_(new base::WaitableEvent(true, false)),
         begin_time_(begin_time),
         is_removing_(false),
         resource_context_(resource_context),
         channel_(NULL) {
+  }
+
+  virtual ~Context() {
+  }
+
+  // Initialize on the IO thread.
+  void Init(const std::string& mime_type) {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+    remove_start_time_ = base::Time::Now();
+    is_removing_ = true;
     // Balanced in OnChannelOpened or OnError. Exactly one them will eventually
     // be called, so we need to keep this object around until then.
     AddRef();
-    remove_start_time_ = base::Time::Now();
-    BrowserThread::PostTask(
-        BrowserThread::IO,
-        FROM_HERE,
-        base::Bind(&Context::Init, this, mime_type));
-
-    BrowserThread::PostDelayedTask(
-        BrowserThread::IO,
-        FROM_HERE,
-        base::Bind(&Context::OnTimeout, this),
-        kRemovalTimeoutMs);
+    PluginService::GetInstance()->OpenChannelToNpapiPlugin(
+        0, 0, GURL(), GURL(), mime_type, this);
   }
 
-  virtual ~Context() {
-    if (channel_)
-      BrowserThread::DeleteSoon(BrowserThread::IO, FROM_HERE, channel_);
+  // Called when a timeout happens in order not to block the client
+  // indefinitely.
+  void OnTimeout() {
+    LOG_IF(ERROR, is_removing_) << "Timed out";
+    SignalDone();
   }
 
   // PluginProcessHost::Client methods.
   virtual int ID() OVERRIDE {
     // Generate a unique identifier for this PluginProcessHostClient.
     return ChildProcessHostImpl::GenerateChildProcessUniqueId();
   }
 
   virtual bool OffTheRecord() OVERRIDE {
     return false;
@@ skipping 36 matching lines @@
     return true;
   }
 
   virtual void OnChannelError() OVERRIDE {
     if (is_removing_) {
       NOTREACHED() << "Channel error";
       SignalDone();
     }
   }
 
-
   base::WaitableEvent* event() { return event_.get(); }
 
  private:
-  // Initialize on the IO thread.
-  void Init(const std::string& mime_type) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-    is_removing_ = true;
-    PluginService::GetInstance()->OpenChannelToNpapiPlugin(
-        0, 0, GURL(), GURL(), mime_type, this);
-  }
-
   // Connects the client side of a newly opened plug-in channel.
   void ConnectToChannel(const IPC::ChannelHandle& handle) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
     // If we timed out, don't bother connecting.
     if (!is_removing_)
       return;
 
-    DCHECK(!channel_);
-    channel_ = new IPC::Channel(handle, IPC::Channel::MODE_CLIENT, this);
+    DCHECK(!channel_.get());
+    channel_.reset(new IPC::Channel(handle, IPC::Channel::MODE_CLIENT, this));
     if (!channel_->Connect()) {
       NOTREACHED() << "Couldn't connect to plugin";
       SignalDone();
       return;
     }
 
     if (!channel_->Send(new PluginMsg_ClearSiteData(std::string(),
                                                     kClearAllData,
                                                     begin_time_))) {
       NOTREACHED() << "Couldn't send ClearSiteData message";
       SignalDone();
       return;
     }
   }
 
   // Handles the PluginHostMsg_ClearSiteDataResult message.
   void OnClearSiteDataResult(bool success) {
     LOG_IF(ERROR, !success) << "ClearSiteData returned error";
     UMA_HISTOGRAM_TIMES("ClearPluginData.time",
                         base::Time::Now() - remove_start_time_);
     SignalDone();
   }
 
-  // Called when a timeout happens in order not to block the client
-  // indefinitely.
-  void OnTimeout() {
-    LOG_IF(ERROR, is_removing_) << "Timed out";
-    SignalDone();
-  }
-
   // Signals that we are finished with removing data (successful or not). This
   // method is safe to call multiple times.
   void SignalDone() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
     if (!is_removing_)
       return;
     is_removing_ = false;
     event_->Signal();
   }
 
   scoped_ptr<base::WaitableEvent> event_;
   // The point in time when we start removing data.
   base::Time remove_start_time_;
   // The point in time from which on we remove data.
   base::Time begin_time_;
   bool is_removing_;
 
   // The resource context for the profile.
   const content::ResourceContext& resource_context_;
 
-  // We own the channel, but it's used on the IO thread, so it needs to be
-  // deleted there. It's NULL until we have opened a connection to the plug-in
+  // The channel is NULL until we have opened a connection to the plug-in
   // process.
-  IPC::Channel* channel_;
+  scoped_ptr<IPC::Channel> channel_;
 };
 
 
 PluginDataRemoverImpl::PluginDataRemoverImpl(
     const content::ResourceContext& resource_context)
     : mime_type_(kFlashMimeType),
       resource_context_(resource_context) {
 }
 
 PluginDataRemoverImpl::~PluginDataRemoverImpl() {
 }
 
 base::WaitableEvent* PluginDataRemoverImpl::StartRemoving(
     base::Time begin_time) {
   DCHECK(!context_.get());
-  context_ = new Context(mime_type_, begin_time, resource_context_);
+  context_ = new Context(begin_time, resource_context_);
+  BrowserThread::PostTask(

[jam, 2011/12/07 21:57:12]

nit: usually this is solved by having an Init function on the refcounted object,
and it can do the calls below, since they're an implementation detail of
Context. Here we would just call Context::Init() which does the code below.

[Bernhard Bauer, 2011/12/08 09:43:17]

Done.

+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&Context::Init, context_, mime_type_));
+
+  BrowserThread::PostDelayedTask(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&Context::OnTimeout, context_),
+      kRemovalTimeoutMs);
+
   return context_->event();
 }