Delete UDPClientSocket on same thread as creation. Also refactor.

chrome/browser/extensions/api/socket/socket_api.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 "chrome/browser/extensions/api/socket/socket_api.h"
 
 #include "base/bind.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/socket/socket_api_controller.h"
+#include "chrome/browser/extensions/extension_service.h"
+#include "chrome/browser/profiles/profile.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/browser_thread.h"
 
 using content::BrowserThread;
 
 namespace extensions {
 
 const char kBytesWrittenKey[] = "bytesWritten";
 const char kSocketIdKey[] = "socketId";
 const char kUDPSocketType[] = "udp";
 
-SocketCreateFunction::SocketCreateFunction() {
+SocketController* SocketApiFunction::controller() {
+  return profile()->GetExtensionService()->socket_controller();
 }
 
-SocketCreateFunction::~SocketCreateFunction() {
+bool SocketApiFunction::RunImpl() {
+  if (!Prepare()) {
+    return false;
+  }
+  bool rv = BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&SocketApiFunction::WorkOnIOThread, this));
+  DCHECK(rv);
+  return true;
 }
 
-bool SocketCreateFunction::RunImpl() {
+void SocketApiFunction::WorkOnIOThread() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  Work();
+  bool rv = BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(&SocketApiFunction::RespondOnUIThread, this));
+  DCHECK(rv);
+}
+
+void SocketApiFunction::RespondOnUIThread() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  SendResponse(Respond());
+}
+
+bool SocketCreateFunction::Prepare() {
   std::string socket_type;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &socket_type));
 
   // TODO(miket): this constitutes a second form of truth as to the enum
   // validity. But our unit-test framework skips the enum validation. So in
   // order to get an invalid-enum test to pass, we need duplicative
   // value-checking. Too bad. Fix this if/when the argument validation code is
   // moved to C++ rather than its current JavaScript form.
   if (socket_type != kUDPSocketType) {
     return false;
   }
-
-  bool rv = BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      base::Bind(&SocketCreateFunction::WorkOnIOThread, this));
-  DCHECK(rv);
   return true;
 }
 
-void SocketCreateFunction::WorkOnIOThread() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+void SocketCreateFunction::Work() {
   DictionaryValue* result = new DictionaryValue();
-  SocketController* controller = SocketController::GetInstance();
-
-  int socket_id = controller->CreateUdp(profile(), extension_id(),
-                                       source_url());
+  int socket_id = controller()->CreateUdp(profile(), extension_id(),
+                                          source_url());
   result->SetInteger(kSocketIdKey, socket_id);
   result_.reset(result);
 
-  bool rv = BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE,
-      base::Bind(&SocketCreateFunction::RespondOnUIThread, this));
-  DCHECK(rv);
 }
 
-void SocketCreateFunction::RespondOnUIThread() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  SendResponse(true);
-}
-
-SocketDestroyFunction::SocketDestroyFunction() {
-}
-
-SocketDestroyFunction::~SocketDestroyFunction() {
-}
-
-bool SocketDestroyFunction::RunImpl() {
-  EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &socket_id_));
-
-  bool rv = BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      base::Bind(&SocketDestroyFunction::WorkOnIOThread, this));
-  DCHECK(rv);
+bool SocketCreateFunction::Respond() {
   return true;
 }
 
-void SocketDestroyFunction::WorkOnIOThread() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  SocketController* controller = SocketController::GetInstance();
-  controller->DestroyUdp(socket_id_);
-
-  bool rv = BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE,
-      base::Bind(&SocketDestroyFunction::RespondOnUIThread, this));
-  DCHECK(rv);
+bool SocketDestroyFunction::Prepare() {
+  EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &socket_id_));
+  return true;
 }
 
-void SocketDestroyFunction::RespondOnUIThread() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  SendResponse(true);
+void SocketDestroyFunction::Work() {
+  controller()->DestroyUdp(socket_id_);
 }
 
-SocketConnectFunction::SocketConnectFunction() {
+bool SocketDestroyFunction::Respond() {
+  return true;
 }
 
-SocketConnectFunction::~SocketConnectFunction() {
-}
-
-bool SocketConnectFunction::RunImpl() {
+bool SocketConnectFunction::Prepare() {
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &socket_id_));
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(1, &address_));
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(2, &port_));
-
-  bool rv = BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      base::Bind(&SocketConnectFunction::WorkOnIOThread, this));
-  DCHECK(rv);
   return true;
 }
 
-void SocketConnectFunction::WorkOnIOThread() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-
-  SocketController* controller = SocketController::GetInstance();
-  bool result = controller->ConnectUdp(socket_id_, address_, port_);
+void SocketConnectFunction::Work() {
+  bool result = controller()->ConnectUdp(socket_id_, address_, port_);
   result_.reset(Value::CreateBooleanValue(result));
-
-  bool rv = BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE,
-      base::Bind(&SocketConnectFunction::RespondOnUIThread, this));
-  DCHECK(rv);
 }
 
-void SocketConnectFunction::RespondOnUIThread() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  SendResponse(true);
-}
-
-SocketCloseFunction::SocketCloseFunction() {
-}
-
-SocketCloseFunction::~SocketCloseFunction() {
-}
-
-bool SocketCloseFunction::RunImpl() {
-  EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &socket_id_));
-
-  bool rv = BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      base::Bind(&SocketCloseFunction::WorkOnIOThread, this));
-  DCHECK(rv);
+bool SocketConnectFunction::Respond() {
   return true;
 }
 
-void SocketCloseFunction::WorkOnIOThread() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-
-  SocketController* controller = SocketController::GetInstance();
-  controller->CloseUdp(socket_id_);
-  result_.reset(Value::CreateNullValue());
-
-  bool rv = BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE,
-      base::Bind(&SocketCloseFunction::RespondOnUIThread, this));
-  DCHECK(rv);
-}
-
-void SocketCloseFunction::RespondOnUIThread() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  SendResponse(true);
-}
-
-SocketWriteFunction::SocketWriteFunction() {
-}
-
-SocketWriteFunction::~SocketWriteFunction() {
-}
-
-bool SocketWriteFunction::RunImpl() {
+bool SocketCloseFunction::Prepare() {
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &socket_id_));
-  EXTENSION_FUNCTION_VALIDATE(args_->GetString(1, &message_));
-
-  bool rv = BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      base::Bind(&SocketWriteFunction::WorkOnIOThread, this));
-  DCHECK(rv);
   return true;
 }
 
-void SocketWriteFunction::WorkOnIOThread() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+void SocketCloseFunction::Work() {
+  controller()->CloseUdp(socket_id_);
+  result_.reset(Value::CreateNullValue());
+}
 
-  SocketController* controller = SocketController::GetInstance();
-  int bytesWritten = controller->WriteUdp(socket_id_, message_);
+bool SocketCloseFunction::Respond() {
+  return true;
+}
+
+bool SocketWriteFunction::Prepare() {
+  EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &socket_id_));
+  EXTENSION_FUNCTION_VALIDATE(args_->GetString(1, &message_));
+  return true;
+}
+
+void SocketWriteFunction::Work() {
+  int bytesWritten = controller()->WriteUdp(socket_id_, message_);
 
   DictionaryValue* result = new DictionaryValue();
   result->SetInteger(kBytesWrittenKey, bytesWritten);
   result_.reset(result);
-  bool rv = BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE,
-      base::Bind(&SocketWriteFunction::RespondOnUIThread, this));
-  DCHECK(rv);
 }
 
-void SocketWriteFunction::RespondOnUIThread() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  SendResponse(true);
+bool SocketWriteFunction::Respond() {
+  return true;
 }
 
 }  // namespace extensions