RefCounted types should not have public destructors, content/browser part 2

content/common/gpu/gpu_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.
 
 #if defined(OS_WIN)
 #include <windows.h>
 #endif
 
 #include "content/common/gpu/gpu_channel.h"
 
@@ skipping 41 matching lines @@
 
   channel_id_ = IPC::Channel::GenerateVerifiedChannelID("gpu");
   const CommandLine* command_line = CommandLine::ForCurrentProcess();
   log_messages_ = command_line->HasSwitch(switches::kLogPluginMessages);
   disallowed_features_.multisampling =
       command_line->HasSwitch(switches::kDisableGLMultisampling);
   disallowed_features_.driver_bug_workarounds =
       command_line->HasSwitch(switches::kDisableGpuDriverBugWorkarounds);
 }
 
-GpuChannel::~GpuChannel() {
+
+bool GpuChannel::Init(base::MessageLoopProxy* io_message_loop,
+                      base::WaitableEvent* shutdown_event) {
+  DCHECK(!channel_.get());
+
+  // Map renderer ID to a (single) channel to that process.
+  channel_.reset(new IPC::SyncChannel(
+      channel_id_,
+      IPC::Channel::MODE_SERVER,
+      this,
+      io_message_loop,
+      false,
+      shutdown_event));
+
+  return true;
 }
 
+std::string GpuChannel::GetChannelName() {
+  return channel_id_;
+}
+
+#if defined(OS_POSIX)
+int GpuChannel::TakeRendererFileDescriptor() {
+  if (!channel_.get()) {
+    NOTREACHED();
+    return -1;
+  }
+  return channel_->TakeClientFileDescriptor();
+}
+#endif  // defined(OS_POSIX)
+
 bool GpuChannel::OnMessageReceived(const IPC::Message& message) {
   if (log_messages_) {
     DVLOG(1) << "received message @" << &message << " on channel @" << this
              << " with type " << message.type();
   }
 
   // Control messages are not deferred and can be handled out of order with
   // respect to routed ones.
   if (message.routing_id() == MSG_ROUTING_CONTROL)
     return OnControlMessageReceived(message);
@@ skipping 64 matching lines @@
   // not emptied here, which ensures that OnMessageReceived will continue to
   // defer newly received messages until the ones in the queue have all been
   // handled by HandleMessage. HandleMessage is invoked as a
   // task to prevent reentrancy.
   MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&GpuChannel::HandleMessage, weak_factory_.GetWeakPtr()));
   handle_messages_scheduled_ = true;
 }
 
-void GpuChannel::LoseAllContexts() {
-  gpu_channel_manager_->LoseAllContexts();
-}
-
-void GpuChannel::DestroySoon() {
-  MessageLoop::current()->PostTask(
-      FROM_HERE, base::Bind(&GpuChannel::OnDestroy, this));
-}
-
-void GpuChannel::OnDestroy() {
-  TRACE_EVENT0("gpu", "GpuChannel::OnDestroy");
-  gpu_channel_manager_->RemoveChannel(client_id_);
-}
-
 void GpuChannel::CreateViewCommandBuffer(
     const gfx::GLSurfaceHandle& window,
     int32 surface_id,
     const GPUCreateCommandBufferConfig& init_params,
     int32* route_id) {
   *route_id = MSG_ROUTING_NONE;
   content::GetContentClient()->SetActiveURL(init_params.active_url);
 
 #if defined(ENABLE_GPU)
   WillCreateCommandBuffer(init_params.gpu_preference);
@@ skipping 16 matching lines @@
       software_));
   router_.AddRoute(*route_id, stub.get());
   stubs_.AddWithID(stub.release(), *route_id);
 #endif  // ENABLE_GPU
 }
 
 GpuCommandBufferStub* GpuChannel::LookupCommandBuffer(int32 route_id) {
   return stubs_.Lookup(route_id);
 }
 
+void GpuChannel::LoseAllContexts() {
+  gpu_channel_manager_->LoseAllContexts();
+}
+
+void GpuChannel::DestroySoon() {
+  MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&GpuChannel::OnDestroy, this));
+}
+
+int GpuChannel::GenerateRouteID() {
+  static int last_id = 0;
+  return ++last_id;
+}
+
+void GpuChannel::AddRoute(int32 route_id, IPC::Channel::Listener* listener) {
+  router_.AddRoute(route_id, listener);
+}
+
+void GpuChannel::RemoveRoute(int32 route_id) {
+  router_.RemoveRoute(route_id);
+}
+
+bool GpuChannel::ShouldPreferDiscreteGpu() const {
+  return num_contexts_preferring_discrete_gpu_ > 0;
+}
+
+GpuChannel::~GpuChannel() {}
+
+void GpuChannel::OnDestroy() {
+  TRACE_EVENT0("gpu", "GpuChannel::OnDestroy");
+  gpu_channel_manager_->RemoveChannel(client_id_);
+}
+
 bool GpuChannel::OnControlMessageReceived(const IPC::Message& msg) {
   // Always use IPC_MESSAGE_HANDLER_DELAY_REPLY for synchronous message handlers
   // here. This is so the reply can be delayed if the scheduler is unscheduled.
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(GpuChannel, msg)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuChannelMsg_CreateOffscreenCommandBuffer,
                                     OnCreateOffscreenCommandBuffer)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuChannelMsg_DestroyCommandBuffer,
                                     OnDestroyCommandBuffer)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuChannelMsg_WillGpuSwitchOccur,
@@ skipping 68 matching lines @@
   if (stub->HasMoreWork()) {
     MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&GpuChannel::PollWork,
                    weak_factory_.GetWeakPtr(),
                    stub->route_id()),
         base::TimeDelta::FromMilliseconds(delay));
   }
 }
 
-int GpuChannel::GenerateRouteID() {
-  static int last_id = 0;
-  return ++last_id;
-}
-
-void GpuChannel::AddRoute(int32 route_id, IPC::Channel::Listener* listener) {
-  router_.AddRoute(route_id, listener);
-}
-
-void GpuChannel::RemoveRoute(int32 route_id) {
-  router_.RemoveRoute(route_id);
-}
-
-bool GpuChannel::ShouldPreferDiscreteGpu() const {
-  return num_contexts_preferring_discrete_gpu_ > 0;
-}
-
 void GpuChannel::OnCreateOffscreenCommandBuffer(
     const gfx::Size& size,
     const GPUCreateCommandBufferConfig& init_params,
     IPC::Message* reply_message) {
   int32 route_id = MSG_ROUTING_NONE;
 
   content::GetContentClient()->SetActiveURL(init_params.active_url);
 #if defined(ENABLE_GPU)
   WillCreateCommandBuffer(init_params.gpu_preference);
 
@@ skipping 70 matching lines @@
       reply_message,
       will_switch_occur);
   Send(reply_message);
 }
 
 void GpuChannel::OnCloseChannel() {
   gpu_channel_manager_->RemoveChannel(client_id_);
   // At this point "this" is deleted!
 }
 
-bool GpuChannel::Init(base::MessageLoopProxy* io_message_loop,
-                      base::WaitableEvent* shutdown_event) {
-  DCHECK(!channel_.get());
-
-  // Map renderer ID to a (single) channel to that process.
-  channel_.reset(new IPC::SyncChannel(
-      channel_id_,
-      IPC::Channel::MODE_SERVER,
-      this,
-      io_message_loop,
-      false,
-      shutdown_event));
-
-  return true;
-}
-
 void GpuChannel::WillCreateCommandBuffer(gfx::GpuPreference gpu_preference) {
   if (gpu_preference == gfx::PreferDiscreteGpu)
     ++num_contexts_preferring_discrete_gpu_;
 }
 
 void GpuChannel::DidDestroyCommandBuffer(gfx::GpuPreference gpu_preference) {
   if (gpu_preference == gfx::PreferDiscreteGpu)
     --num_contexts_preferring_discrete_gpu_;
   DCHECK_GE(num_contexts_preferring_discrete_gpu_, 0);
 }
-
-std::string GpuChannel::GetChannelName() {
-  return channel_id_;
-}
-
-#if defined(OS_POSIX)
-int GpuChannel::TakeRendererFileDescriptor() {
-  if (!channel_.get()) {
-    NOTREACHED();
-    return -1;
-  }
-  return channel_->TakeClientFileDescriptor();
-}
-#endif  // defined(OS_POSIX)