Remove some content_child dependency from content_common

content/child/child_thread.h

 // 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.
 
 #ifndef CONTENT_CHILD_CHILD_THREAD_H_
 #define CONTENT_CHILD_CHILD_THREAD_H_
 
 #include <string>
 
 #include "base/basictypes.h"
@@ skipping 48 matching lines @@
   // destructor, so any subsystem that relies on ChildProcess::main_thread()
   // must be terminated before Shutdown returns. In particular, if a subsystem
   // has a thread that post tasks to ChildProcess::main_thread(), that thread
   // should be joined in Shutdown().
   virtual ~ChildThread();
   virtual void Shutdown();
 
   // IPC::Sender implementation:
   virtual bool Send(IPC::Message* msg) OVERRIDE;
 
-  // See documentation on MessageRouter for AddRoute and RemoveRoute
-  void AddRoute(int32 routing_id, IPC::Listener* listener);
-  void RemoveRoute(int32 routing_id);
+  IPC::SyncChannel* channel() { return channel_.get(); }
 
-  IPC::SyncChannel* channel() { return channel_.get(); }
+  MessageRouter* GetRouter();
 
   // Creates a ResourceLoaderBridge.
   // Tests can override this method if they want a custom loading behavior.
   virtual webkit_glue::ResourceLoaderBridge* CreateBridge(
       const webkit_glue::ResourceLoaderBridge::RequestInfo& request_info);
 
   // Allocates a block of shared memory of the given size and
   // maps in into the address space. Returns NULL of failure.
   // Note: On posix, this requires a sync IPC to the browser process,
   // but on windows the child process directly allocates the block.
@@ skipping 73 matching lines @@
   void set_on_channel_error_called(bool on_channel_error_called) {
     on_channel_error_called_ = on_channel_error_called;
   }
 
   // IPC::Listener implementation:
   virtual bool OnMessageReceived(const IPC::Message& msg) OVERRIDE;
   virtual void OnChannelConnected(int32 peer_pid) OVERRIDE;
   virtual void OnChannelError() OVERRIDE;
 
  private:
+  class ChildThreadMessageRouter : public MessageRouter {
+   public:
+    // |sender| must outlive this object.
+    explicit ChildThreadMessageRouter(IPC::Sender* sender);
+    virtual bool Send(IPC::Message* msg) OVERRIDE;
+
+   private:
+    IPC::Sender* const sender_;
+  };
+
   void Init();
 
   // IPC message handlers.
   void OnShutdown();
   void OnSetProfilerStatus(tracked_objects::ThreadData::Status status);
   void OnGetChildProfilerData(int sequence_number);
   void OnDumpHandles();
 #ifdef IPC_MESSAGE_LOG_ENABLED
   void OnSetIPCLoggingEnabled(bool enable);
 #endif
 #if defined(USE_TCMALLOC)
   void OnGetTcmallocStats();
 #endif
 
   void EnsureConnected();
 
   std::string channel_name_;
   scoped_ptr<IPC::SyncChannel> channel_;
 
   // Allows threads other than the main thread to send sync messages.
   scoped_refptr<IPC::SyncMessageFilter> sync_message_filter_;
 
   scoped_refptr<ThreadSafeSender> thread_safe_sender_;
 
   // Implements message routing functionality to the consumers of ChildThread.
-  MessageRouter router_;
+  ChildThreadMessageRouter router_;
 
   // Handles resource loads for this process.
   scoped_ptr<ResourceDispatcher> resource_dispatcher_;
 
   // Handles SocketStream for this process.
   scoped_ptr<SocketStreamDispatcher> socket_stream_dispatcher_;
 
   scoped_ptr<WebSocketDispatcher> websocket_dispatcher_;
 
   // The OnChannelError() callback was invoked - the channel is dead, don't
@@ skipping 25 matching lines @@
   scoped_ptr<base::PowerMonitor> power_monitor_;
 
   bool in_browser_process_;
 
   DISALLOW_COPY_AND_ASSIGN(ChildThread);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_CHILD_CHILD_THREAD_H_