Cleanup: make ExtensionRequestSender manage its IPC responses directly, rather

chrome/browser/extensions/extension_function.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 "chrome/browser/extensions/extension_function.h"
 
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "chrome/browser/extensions/extension_function_dispatcher.h"
 #include "chrome/browser/extensions/extension_service.h"
@@ skipping 103 matching lines @@
   return false;
 }
 
 bool ExtensionFunction::HasOptionalArgument(size_t index) {
   Value* value;
   return args_->Get(index, &value) && !value->IsType(Value::TYPE_NULL);
 }
 
 void ExtensionFunction::SendResponseImpl(base::ProcessHandle process,
                                          IPC::Sender* ipc_sender,
-                                         int routing_id,
                                          bool success) {
   DCHECK(ipc_sender);
   if (bad_message_) {
     HandleBadMessage(process);
     return;
   }
 
   // Value objects can't be directly serialized in our IPC code, so we wrap the
   // result_ Value with a ListValue (also transferring ownership of result_).
   base::ListValue result_wrapper;
   if (result_.get())
     result_wrapper.Append(result_.release());
 
   ipc_sender->Send(new ExtensionMsg_Response(
-      routing_id, request_id_, success, result_wrapper, GetError()));
+      request_id_, success, result_wrapper, GetError()));
 }
 
 void ExtensionFunction::HandleBadMessage(base::ProcessHandle process) {
   LOG(ERROR) << "bad extension message " << name_ << " : terminating renderer.";
   if (content::RenderProcessHost::run_renderer_in_process()) {
     // In single process mode it is better if we don't suicide but just crash.
     CHECK(false);
   } else {
     NOTREACHED();
     content::RecordAction(UserMetricsAction("BadMessageTerminate_EFD"));
@@ skipping 91 matching lines @@
 
 void UIThreadExtensionFunction::SendResponse(bool success) {
   if (delegate_) {
     delegate_->OnSendResponse(this, success, bad_message_);
   } else {
     if (!render_view_host_ || !dispatcher())
       return;
 
     SendResponseImpl(render_view_host_->GetProcess()->GetHandle(),
                      render_view_host_,
-                     render_view_host_->GetRoutingID(),
                      success);
   }
 }
 
-IOThreadExtensionFunction::IOThreadExtensionFunction()
-    : routing_id_(-1) {
+IOThreadExtensionFunction::IOThreadExtensionFunction() {
 }
 
 IOThreadExtensionFunction::~IOThreadExtensionFunction() {
 }
 
 IOThreadExtensionFunction*
 IOThreadExtensionFunction::AsIOThreadExtensionFunction() {
   return this;
 }
 
 void IOThreadExtensionFunction::Destruct() const {
   BrowserThread::DeleteOnIOThread::Destruct(this);
 }
 
 void IOThreadExtensionFunction::SendResponse(bool success) {
   if (!ipc_sender())
     return;
 
-  SendResponseImpl(ipc_sender()->peer_handle(),
-                   ipc_sender(), routing_id_, success);
+  SendResponseImpl(ipc_sender()->peer_handle(), ipc_sender(), success);
 }
 
 AsyncExtensionFunction::AsyncExtensionFunction() {
 }
 
 AsyncExtensionFunction::~AsyncExtensionFunction() {
 }
 
 SyncExtensionFunction::SyncExtensionFunction() {
 }
 
 SyncExtensionFunction::~SyncExtensionFunction() {
 }
 
 void SyncExtensionFunction::Run() {
   SendResponse(RunImpl());
 }
 
 SyncIOThreadExtensionFunction::SyncIOThreadExtensionFunction() {
 }
 
 SyncIOThreadExtensionFunction::~SyncIOThreadExtensionFunction() {
 }
 
 void SyncIOThreadExtensionFunction::Run() {
   SendResponse(RunImpl());
 }