RefCounted types should not have public destructors, content/ remaining bits

content/plugin/plugin_channel.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 "content/plugin/plugin_channel.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/process_util.h"
 #include "base/string_util.h"
@@ skipping 23 matching lines @@
 const int kPluginReleaseTimeMinutes = 5;
 
 }  // namespace
 
 // If a sync call to the renderer results in a modal dialog, we need to have a
 // way to know so that we can run a nested message loop to simulate what would
 // happen in a single process browser and avoid deadlock.
 class PluginChannel::MessageFilter : public IPC::ChannelProxy::MessageFilter {
  public:
   MessageFilter() : channel_(NULL) { }
-  ~MessageFilter() {
-    // Clean up in case of renderer crash.
-    for (ModalDialogEventMap::iterator i = modal_dialog_event_map_.begin();
-        i != modal_dialog_event_map_.end(); ++i) {
-      delete i->second.event;
-    }
-  }
 
   base::WaitableEvent* GetModalDialogEvent(
       gfx::NativeViewId containing_window) {
     base::AutoLock auto_lock(modal_dialog_event_map_lock_);
     if (!modal_dialog_event_map_.count(containing_window)) {
       NOTREACHED();
       return NULL;
     }
 
     return modal_dialog_event_map_[containing_window].event;
@@ skipping 15 matching lines @@
     MessageLoop::current()->DeleteSoon(
         FROM_HERE, modal_dialog_event_map_[containing_window].event);
     modal_dialog_event_map_.erase(containing_window);
   }
 
   bool Send(IPC::Message* message) {
     // Need this function for the IPC_MESSAGE_HANDLER_DELAY_REPLY macro.
     return channel_->Send(message);
   }
 
- private:
+  // IPC::ChannelProxy::MessageFilter:
   void OnFilterAdded(IPC::Channel* channel) { channel_ = channel; }
 
   bool OnMessageReceived(const IPC::Message& message) {
     IPC_BEGIN_MESSAGE_MAP(PluginChannel::MessageFilter, message)
       IPC_MESSAGE_HANDLER_DELAY_REPLY(PluginMsg_Init, OnInit)
       IPC_MESSAGE_HANDLER(PluginMsg_SignalModalDialogEvent,
                           OnSignalModalDialogEvent)
       IPC_MESSAGE_HANDLER(PluginMsg_ResetModalDialogEvent,
                           OnResetModalDialogEvent)
     IPC_END_MESSAGE_MAP()
     return message.type() == PluginMsg_SignalModalDialogEvent::ID ||
            message.type() == PluginMsg_ResetModalDialogEvent::ID;
   }
 
+
+
+ protected:
+  virtual ~MessageFilter() {
+    // Clean up in case of renderer crash.
+    for (ModalDialogEventMap::iterator i = modal_dialog_event_map_.begin();
+        i != modal_dialog_event_map_.end(); ++i) {
+      delete i->second.event;
+    }
+  }
+
+ private:
   void OnInit(const PluginMsg_Init_Params& params, IPC::Message* reply_msg) {
     base::AutoLock auto_lock(modal_dialog_event_map_lock_);
     if (modal_dialog_event_map_.count(params.containing_window)) {
       modal_dialog_event_map_[params.containing_window].refcount++;
       return;
     }
 
     WaitableEventWrapper wrapper;
     wrapper.event = new base::WaitableEvent(true, false);
     wrapper.refcount = 1;
@@ skipping 42 matching lines @@
     channel->renderer_id_ = renderer_id;
 
   return channel;
 }
 
 // static
 void PluginChannel::NotifyRenderersOfPendingShutdown() {
   Broadcast(new PluginHostMsg_PluginShuttingDown());
 }
 
-PluginChannel::PluginChannel()
-    : renderer_id_(-1),
-      in_send_(0),
-      incognito_(false),
-      filter_(new MessageFilter()) {
-  set_send_unblocking_only_during_unblock_dispatch();
-  ChildProcess::current()->AddRefProcess();
-  const CommandLine* command_line = CommandLine::ForCurrentProcess();
-  log_messages_ = command_line->HasSwitch(switches::kLogPluginMessages);
-}
-
-PluginChannel::~PluginChannel() {
-  MessageLoop::current()->PostDelayedTask(
-      FROM_HERE,
-      base::Bind(&PluginReleaseCallback),
-      base::TimeDelta::FromMinutes(kPluginReleaseTimeMinutes));
-}
-
 bool PluginChannel::Send(IPC::Message* msg) {
   in_send_++;
   if (log_messages_) {
     VLOG(1) << "sending message @" << msg << " on channel @" << this
             << " with type " << msg->type();
   }
   bool result = NPChannelBase::Send(msg);
   in_send_--;
   return result;
 }
 
 bool PluginChannel::OnMessageReceived(const IPC::Message& msg) {
   if (log_messages_) {
     VLOG(1) << "received message @" << &msg << " on channel @" << this
             << " with type " << msg.type();
   }
   return NPChannelBase::OnMessageReceived(msg);
 }
 
+void PluginChannel::OnChannelError() {
+  NPChannelBase::OnChannelError();
+  CleanUp();
+}
+
+int PluginChannel::GenerateRouteID() {
+  static int last_id = 0;
+  return ++last_id;
+}
+
+base::WaitableEvent* PluginChannel::GetModalDialogEvent(
+    gfx::NativeViewId containing_window) {
+  return filter_->GetModalDialogEvent(containing_window);
+}
+
+PluginChannel::~PluginChannel() {
+  MessageLoop::current()->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&PluginReleaseCallback),
+      base::TimeDelta::FromMinutes(kPluginReleaseTimeMinutes));
+}
+
+void PluginChannel::CleanUp() {
+  // We need to clean up the stubs so that they call NPPDestroy.  This will
+  // also lead to them releasing their reference on this object so that it can
+  // be deleted.
+  for (size_t i = 0; i < plugin_stubs_.size(); ++i)
+    RemoveRoute(plugin_stubs_[i]->instance_id());
+
+  // Need to addref this object temporarily because otherwise removing the last
+  // stub will cause the destructor of this object to be called, however at
+  // that point plugin_stubs_ will have one element and its destructor will be
+  // called twice.
+  scoped_refptr<PluginChannel> me(this);
+
+  plugin_stubs_.clear();
+}
+
+bool PluginChannel::Init(base::MessageLoopProxy* ipc_message_loop,
+                         bool create_pipe_now,
+                         base::WaitableEvent* shutdown_event) {
+  if (!NPChannelBase::Init(ipc_message_loop, create_pipe_now, shutdown_event))
+    return false;
+
+  channel_->AddFilter(filter_.get());
+  return true;
+}
+
+PluginChannel::PluginChannel()
+    : renderer_id_(-1),
+      in_send_(0),
+      incognito_(false),
+      filter_(new MessageFilter()) {
+  set_send_unblocking_only_during_unblock_dispatch();
+  ChildProcess::current()->AddRefProcess();
+  const CommandLine* command_line = CommandLine::ForCurrentProcess();
+  log_messages_ = command_line->HasSwitch(switches::kLogPluginMessages);
+}
+
 bool PluginChannel::OnControlMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PluginChannel, msg)
     IPC_MESSAGE_HANDLER(PluginMsg_CreateInstance, OnCreateInstance)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(PluginMsg_DestroyInstance,
                                     OnDestroyInstance)
     IPC_MESSAGE_HANDLER(PluginMsg_GenerateRouteID, OnGenerateRouteID)
     IPC_MESSAGE_HANDLER(PluginMsg_ClearSiteData, OnClearSiteData)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
@@ skipping 30 matching lines @@
     }
   }
 
   NOTREACHED() << "Couldn't find WebPluginDelegateStub to destroy";
 }
 
 void PluginChannel::OnGenerateRouteID(int* route_id) {
   *route_id = GenerateRouteID();
 }
 
-int PluginChannel::GenerateRouteID() {
-  static int last_id = 0;
-  return ++last_id;
-}
-
 void PluginChannel::OnClearSiteData(const std::string& site,
                                     uint64 flags,
                                     uint64 max_age) {
   bool success = false;
   CommandLine* command_line = CommandLine::ForCurrentProcess();
   FilePath path = command_line->GetSwitchValuePath(switches::kPluginPath);
   scoped_refptr<webkit::npapi::PluginLib> plugin_lib(
       webkit::npapi::PluginLib::CreatePluginLib(path));
   if (plugin_lib.get()) {
     NPError err = plugin_lib->NP_Initialize();
     if (err == NPERR_NO_ERROR) {
       const char* site_str = site.empty() ? NULL : site.c_str();
       err = plugin_lib->NP_ClearSiteData(site_str, flags, max_age);
       std::string site_name =
           site.empty() ? "NULL"
                        : base::StringPrintf("\"%s\"", site_str);
       VLOG(1) << "NPP_ClearSiteData(" << site_name << ", " << flags << ", "
               << max_age << ") returned " << err;
       success = (err == NPERR_NO_ERROR);
     }
   }
   Send(new PluginHostMsg_ClearSiteDataResult(success));
 }
-
-base::WaitableEvent* PluginChannel::GetModalDialogEvent(
-    gfx::NativeViewId containing_window) {
-  return filter_->GetModalDialogEvent(containing_window);
-}
-
-void PluginChannel::OnChannelError() {
-  NPChannelBase::OnChannelError();
-  CleanUp();
-}
-
-void PluginChannel::CleanUp() {
-  // We need to clean up the stubs so that they call NPPDestroy.  This will
-  // also lead to them releasing their reference on this object so that it can
-  // be deleted.
-  for (size_t i = 0; i < plugin_stubs_.size(); ++i)
-    RemoveRoute(plugin_stubs_[i]->instance_id());
-
-  // Need to addref this object temporarily because otherwise removing the last
-  // stub will cause the destructor of this object to be called, however at
-  // that point plugin_stubs_ will have one element and its destructor will be
-  // called twice.
-  scoped_refptr<PluginChannel> me(this);
-
-  plugin_stubs_.clear();
-}
-
-bool PluginChannel::Init(base::MessageLoopProxy* ipc_message_loop,
-                         bool create_pipe_now,
-                         base::WaitableEvent* shutdown_event) {
-  if (!NPChannelBase::Init(ipc_message_loop, create_pipe_now, shutdown_event))
-    return false;
-
-  channel_->AddFilter(filter_.get());
-  return true;
-}
-