Base infrastructure for Networking Private API on Windows and Mac.

chrome/browser/extensions/api/networking_private/networking_private_process_client.cc

Index: chrome/browser/extensions/api/networking_private/networking_private_process_client.cc
diff --git a/chrome/browser/extensions/api/networking_private/networking_private_process_client.cc b/chrome/browser/extensions/api/networking_private/networking_private_process_client.cc
new file mode 100644
index 0000000000000000000000000000000000000000..8b384a4bdabc7a387f68ed572ebb95915c000c08
--- /dev/null
+++ b/chrome/browser/extensions/api/networking_private/networking_private_process_client.cc
@@ -0,0 +1,504 @@
+// 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/api/networking_private/networking_private_process_client.h"
+
+#include "base/bind.h"
+#include "base/lazy_instance.h"
+#include "base/strings/string_number_conversions.h"
+#include "chrome/browser/browser_process.h"
+#include "chrome/browser/extensions/event_names.h"
+#include "chrome/browser/extensions/event_router.h"
+#include "chrome/browser/extensions/extension_system.h"
+#include "chrome/common/extensions/api/networking_private.h"
+#include "chrome/common/networking_private_messages.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/utility_process_host.h"
+
+using content::BrowserThread;
+using content::UtilityProcessHost;
+namespace api = extensions::api::networking_private;
+
+NetworkingPrivateProcessClient::NetworkingPrivateProcessClient(Profile* profile)
+    : profile_(profile) {
+  Start();
+}
+
+NetworkingPrivateProcessClient::~NetworkingPrivateProcessClient() {}

[stevenjb, 2013/08/13 23:39:04]

nit: } on new line

[mef, 2013/09/24 21:14:37]

git cl format insists otherwise.

+
+void NetworkingPrivateProcessClient::Start() {
+  BrowserThread::ID thread_id;
+  CHECK(BrowserThread::GetCurrentThreadIdentifier(&thread_id));
+  BrowserThread::PostTask(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&NetworkingPrivateProcessClient::StartProcessOnIOThread,
+                 this,
+                 thread_id));
+}
+
+void NetworkingPrivateProcessClient::StartProcessOnIOThread(
+    BrowserThread::ID thread_id) {
+  utility_process_host_ = UtilityProcessHost::Create(
+      this, BrowserThread::GetMessageLoopProxyForThread(thread_id).get())
+      ->AsWeakPtr();
+  utility_process_host_->DisableSandbox();
+  utility_process_host_->StartBatchMode();
+
+  // utility_process_host_->Send(new ProfileImportProcessMsg_StartImport(
+  //    source_profile_, items_, localized_strings));

[stevenjb, 2013/08/13 23:39:04]

??

[mef, 2013/09/24 21:14:37]

Done.

+}
+
+void NetworkingPrivateProcessClient::OnProcessCrashed(int exit_code) {
+  DLOG(ERROR) << __FUNCTION__;
+  // if (cancelled_)

[Greg Spencer (Chromium), 2013/08/13 23:59:30]

Yes, remove all commented out code (or uncomment).

[mef, 2013/09/24 21:14:37]

Done. I've added proper logic to handle utility process crash.

+  //  return;
+
+  // process_importer_host_->Cancel();

[stevenjb, 2013/08/13 23:39:04]

??

[mef, 2013/09/24 21:14:37]

Done.

+}
+
+bool NetworkingPrivateProcessClient::OnMessageReceived(
+    const IPC::Message& message) {
+  bool handled = true;
+  IPC_BEGIN_MESSAGE_MAP(NetworkingPrivateProcessClient, message)
+  // Responses from NetworkingPrivateHandler.
+  IPC_MESSAGE_HANDLER(NetworkingPrivateMsg_GetProperties_Succeeded,
+                      OnGetPropertiesSucceeded)
+  IPC_MESSAGE_HANDLER(NetworkingPrivateMsg_GetProperties_Failed,
+                      OnGetPropertiesFailed)
+  IPC_MESSAGE_HANDLER(NetworkingPrivateMsg_StartConnect_Succeeded,
+                      OnStartConnectSucceeded)
+  IPC_MESSAGE_HANDLER(NetworkingPrivateMsg_StartConnect_Failed,
+                      OnStartConnectFailed)
+  IPC_MESSAGE_HANDLER(NetworkingPrivateMsg_StartDisconnect_Succeeded,
+                      OnStartDisconnectSucceeded)
+  IPC_MESSAGE_HANDLER(NetworkingPrivateMsg_StartDisconnect_Failed,
+                      OnStartDisconnectFailed)
+  IPC_MESSAGE_HANDLER(NetworkingPrivateMsg_SetProperties_Succeeded,
+                      OnSetPropertiesSucceeded)
+  IPC_MESSAGE_HANDLER(NetworkingPrivateMsg_SetProperties_Failed,
+                      OnSetPropertiesFailed)
+  IPC_MESSAGE_HANDLER(NetworkingPrivateMsg_GetVisibleNetworksSucceeded,
+                      OnGetVisibleNetworksSucceeded)
+  IPC_MESSAGE_HANDLER(NetworkingPrivateMsg_NetworksChanged_Event,
+                      OnNetworksChangedEvent)
+  IPC_MESSAGE_HANDLER(NetworkingPrivateMsg_NetworkListChanged_Event,
+                      OnNetworkListChangedEvent)
+  IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP()
+  return handled;
+}
+
+void NetworkingPrivateProcessClient::GetProperties(
+    const std::string& service_path,
+    const DictionaryResultCallback& callback,
+    const ErrorCallback& error_callback) {
+  // MessageBoxA(NULL, __FUNCTION__, "Debug Me", MB_OK);

[stevenjb, 2013/08/13 23:39:04]

??

[mef, 2013/09/24 21:14:37]

Done.

+  get_properties_success_callback_ = callback;
+  get_properties_error_callback_ = error_callback;
+  BrowserThread::PostTask(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&NetworkingPrivateProcessClient::OnGetPropertiesStart,

[cbentzel, 2013/08/19 19:46:34]

What happens if the utility process is killed while this is outstanding? Worried
that the extension API call will stall forever rather than error back to the
user in that case.

[mef, 2013/08/21 17:25:34]

Good point. I guess NetworkingPrivateProcessClient::OnProcessCrashed should
invoke error_callback,
which also points out that there is no need to have different error_callbacks
for different api calls. 

[mef, 2013/09/24 21:14:37]

Done.

+                 this,
+                 service_path));
+}
+
+// Message handlers
+void NetworkingPrivateProcessClient::OnGetPropertiesStart(
+    const std::string& network_guid) {
+  utility_process_host_->Send(
+      new NetworkingPrivateMsg_GetProperties(network_guid));
+}
+
+void NetworkingPrivateProcessClient::OnGetPropertiesSucceeded(
+    const std::string& network_guid,
+    const base::DictionaryValue& properties) {
+  LOG(INFO) << properties;
+  if (!get_properties_success_callback_.is_null())
+    get_properties_success_callback_.Run(network_guid, properties);
+}
+
+void NetworkingPrivateProcessClient::OnGetPropertiesFailed(
+    const std::string& error_code,
+    const base::DictionaryValue& error_data) {
+  scoped_ptr<DictionaryValue> error_data_ptr(error_data.DeepCopy());
+  if (!get_properties_error_callback_.is_null())
+    get_properties_error_callback_.Run(error_code, error_data_ptr.Pass());
+}
+
+// Requests network scan. Broadcasts NetworkListChangedEvent upon completion.
+void NetworkingPrivateProcessClient::RequestNetworkScan() {
+  BrowserThread::PostTask(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&NetworkingPrivateProcessClient::OnRequestNetworkScan, this));
+}
+
+void NetworkingPrivateProcessClient::OnRequestNetworkScan() {
+  utility_process_host_->Send(new NetworkingPrivateMsg_RequestNetworkScan());
+}
+
+void NetworkingPrivateProcessClient::GetVisibleNetworks(
+    const ListResultCallback& callback) {
+  get_visible_networks_callback_ = callback;
+  BrowserThread::PostTask(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&NetworkingPrivateProcessClient::OnGetVisibleNetworks, this));
+}
+
+void NetworkingPrivateProcessClient::OnGetVisibleNetworks() {
+  utility_process_host_->Send(new NetworkingPrivateMsg_GetVisibleNetworks());
+}
+
+void NetworkingPrivateProcessClient::OnGetVisibleNetworksSucceeded(
+    const base::ListValue& network_list) {
+  if (!get_visible_networks_callback_.is_null())
+    get_visible_networks_callback_.Run(network_list);
+}
+
+void NetworkingPrivateProcessClient::StartConnect(
+    const std::string& service_path,
+    const VoidResultCallback& callback,
+    const ErrorCallback& error_callback) {
+  start_connect_success_callback_ = callback;
+  start_connect_error_callback_ = error_callback;
+  BrowserThread::PostTask(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&NetworkingPrivateProcessClient::OnStartConnectStart,
+                 this,
+                 service_path));
+}
+
+// Message handlers
+void NetworkingPrivateProcessClient::OnStartConnectStart(
+    const std::string& network_guid) {
+  utility_process_host_->Send(
+      new NetworkingPrivateMsg_StartConnect(network_guid));
+}
+
+void NetworkingPrivateProcessClient::OnStartConnectSucceeded(
+    const std::string& network_guid) {
+  if (!start_connect_success_callback_.is_null())
+    start_connect_success_callback_.Run();
+}
+
+void NetworkingPrivateProcessClient::OnStartConnectFailed(
+    const std::string& error_code,
+    const base::DictionaryValue& error_data) {
+  scoped_ptr<DictionaryValue> error_data_ptr(error_data.DeepCopy());
+  if (!start_connect_error_callback_.is_null())
+    start_connect_error_callback_.Run(error_code, error_data_ptr.Pass());
+}
+
+void NetworkingPrivateProcessClient::StartDisconnect(
+    const std::string& service_path,
+    const VoidResultCallback& callback,
+    const ErrorCallback& error_callback) {
+  start_disconnect_success_callback_ = callback;
+  start_disconnect_error_callback_ = error_callback;
+  BrowserThread::PostTask(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&NetworkingPrivateProcessClient::OnStartDisconnectStart,
+                 this,
+                 service_path));
+}
+
+void NetworkingPrivateProcessClient::OnStartDisconnectStart(
+    const std::string& network_guid) {
+  utility_process_host_->Send(
+      new NetworkingPrivateMsg_StartDisconnect(network_guid));
+}
+
+void NetworkingPrivateProcessClient::OnStartDisconnectSucceeded(
+    const std::string& network_guid) {
+  if (!start_disconnect_success_callback_.is_null())
+    start_disconnect_success_callback_.Run();
+}
+
+void NetworkingPrivateProcessClient::OnStartDisconnectFailed(
+    const std::string& error_code,
+    const base::DictionaryValue& error_data) {
+  scoped_ptr<DictionaryValue> error_data_ptr(error_data.DeepCopy());
+  if (!start_disconnect_error_callback_.is_null())
+    start_disconnect_error_callback_.Run(error_code, error_data_ptr.Pass());
+}
+
+void NetworkingPrivateProcessClient::SetProperties(
+    const std::string& service_path,
+    const base::DictionaryValue& properties,
+    const VoidResultCallback& callback,
+    const ErrorCallback& error_callback) {
+  set_properties_success_callback_ = callback;
+  set_properties_error_callback_ = error_callback;
+  scoped_ptr<DictionaryValue> properties_ptr(properties.DeepCopy());
+
+  BrowserThread::PostTask(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&NetworkingPrivateProcessClient::OnSetPropertiesStart,
+                 this,
+                 service_path,
+                 base::Passed(&properties_ptr)));
+}
+
+void NetworkingPrivateProcessClient::OnSetPropertiesStart(
+    const std::string& network_guid,
+    scoped_ptr<base::DictionaryValue> properties) {
+  LOG(INFO) << *properties;
+  utility_process_host_->Send(
+      new NetworkingPrivateMsg_SetProperties(network_guid, *properties));
+}
+
+void NetworkingPrivateProcessClient::OnSetPropertiesSucceeded(
+    const std::string& network_guid) {
+  if (!set_properties_success_callback_.is_null())
+    set_properties_success_callback_.Run();
+}
+
+void NetworkingPrivateProcessClient::OnSetPropertiesFailed(
+    const std::string& error_code,
+    const base::DictionaryValue& error_data) {
+  scoped_ptr<DictionaryValue> error_data_ptr(error_data.DeepCopy());
+  if (!set_properties_error_callback_.is_null())
+    set_properties_error_callback_.Run(error_code, error_data_ptr.Pass());
+}
+
+void NetworkingPrivateProcessClient::OnNetworksChangedEvent(
+    const std::vector<std::string>& network_guids) {
+  extensions::EventRouter* event_router =
+      extensions::ExtensionSystem::Get(profile_)->event_router();
+  scoped_ptr<base::ListValue> args(
+      api::OnNetworksChanged::Create(network_guids));
+  scoped_ptr<extensions::Event> netchanged_event(new extensions::Event(
+      extensions::event_names::kOnNetworksChanged, args.Pass()));
+  event_router->BroadcastEvent(netchanged_event.Pass());
+}
+
+void NetworkingPrivateProcessClient::OnNetworkListChangedEvent(
+    const std::vector<std::string>& network_guids) {
+  extensions::EventRouter* event_router =
+      extensions::ExtensionSystem::Get(profile_)->event_router();
+  scoped_ptr<base::ListValue> args(
+      api::OnNetworksChanged::Create(network_guids));
+  scoped_ptr<extensions::Event> netchanged_event(new extensions::Event(
+      extensions::event_names::kOnNetworkListChanged, args.Pass()));
+  event_router->BroadcastEvent(netchanged_event.Pass());
+}
+
+/*

[stevenjb, 2013/08/13 23:39:04]

??

[mef, 2013/09/24 21:14:37]

Done.

+void NetworkingPrivateProcessClient::OnImportStart() {
+  if (cancelled_)
+    return;
+
+  bridge_->NotifyStarted();
+}
+
+void NetworkingPrivateProcessClient::OnImportFinishked(
+    bool succeeded, const std::string& error_msg) {
+  if (cancelled_)
+    return;
+
+  if (!succeeded)
+    LOG(WARNING) << "Import failed.  Error: " << error_msg;
+  Cleanup();
+}
+
+void NetworkingPrivateProcessClient::OnImportItemStart(int item_data) {
+  if (cancelled_)
+    return;
+
+  bridge_->NotifyItemStarted(static_cast<importer::ImportItem>(item_data));
+}
+
+void NetworkingPrivateProcessClient::OnImportItemFinished(int item_data) {
+  if (cancelled_)
+    return;
+
+  importer::ImportItem import_item =
+      static_cast<importer::ImportItem>(item_data);
+  bridge_->NotifyItemEnded(import_item);
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&NetworkingPrivateProcessClient::NotifyItemFinishedOnIOThread,
+                 this,
+                 import_item));
+}
+
+void NetworkingPrivateProcessClient::OnHistoryImportStart(
+    size_t total_history_rows_count) {
+  if (cancelled_)
+    return;
+
+  total_history_rows_count_ = total_history_rows_count;
+  history_rows_.reserve(total_history_rows_count);
+}
+
+void NetworkingPrivateProcessClient::OnHistoryImportGroup(
+    const std::vector<ImporterURLRow>& history_rows_group,
+    int visit_source) {
+  if (cancelled_)
+    return;
+
+  history_rows_.insert(history_rows_.end(), history_rows_group.begin(),
+                       history_rows_group.end());
+  if (history_rows_.size() == total_history_rows_count_)
+    bridge_->SetHistoryItems(history_rows_,
+                             static_cast<importer::VisitSource>(visit_source));
+}
+
+void NetworkingPrivateProcessClient::OnHomePageImportReady(
+    const GURL& home_page) {
+  if (cancelled_)
+    return;
+
+  bridge_->AddHomePage(home_page);
+}
+
+void NetworkingPrivateProcessClient::OnBookmarksImportStart(
+    const string16& first_folder_name,
+    size_t total_bookmarks_count) {
+  if (cancelled_)
+    return;
+
+  bookmarks_first_folder_name_ = first_folder_name;
+  total_bookmarks_count_ = total_bookmarks_count;
+  bookmarks_.reserve(total_bookmarks_count);
+}
+
+void NetworkingPrivateProcessClient::OnBookmarksImportGroup(
+    const std::vector<ImportedBookmarkEntry>& bookmarks_group) {
+  if (cancelled_)
+    return;
+
+  // Collect sets of bookmarks from importer process until we have reached
+  // total_bookmarks_count_:
+  bookmarks_.insert(bookmarks_.end(), bookmarks_group.begin(),
+                    bookmarks_group.end());
+  if (bookmarks_.size() == total_bookmarks_count_)
+    bridge_->AddBookmarks(bookmarks_, bookmarks_first_folder_name_);
+}
+
+void NetworkingPrivateProcessClient::OnFaviconsImportStart(
+    size_t total_favicons_count) {
+  if (cancelled_)
+    return;
+
+  total_favicons_count_ = total_favicons_count;
+  favicons_.reserve(total_favicons_count);
+}
+
+void NetworkingPrivateProcessClient::OnFaviconsImportGroup(
+    const std::vector<ImportedFaviconUsage>& favicons_group) {
+  if (cancelled_)
+    return;
+
+  favicons_.insert(favicons_.end(), favicons_group.begin(),
+                    favicons_group.end());
+  if (favicons_.size() == total_favicons_count_)
+    bridge_->SetFavicons(favicons_);
+}
+
+void NetworkingPrivateProcessClient::OnPasswordFormImportReady(
+    const content::PasswordForm& form) {
+  if (cancelled_)
+    return;
+
+  bridge_->SetPasswordForm(form);
+}
+
+void NetworkingPrivateProcessClient::OnKeywordsImportReady(
+    const std::vector<importer::URLKeywordInfo>& url_keywords,
+    bool unique_on_host_and_path) {
+  if (cancelled_)
+    return;
+  bridge_->SetKeywords(url_keywords, unique_on_host_and_path);
+}
+
+void NetworkingPrivateProcessClient::OnFirefoxSearchEngineDataReceived(
+    const std::vector<std::string> search_engine_data) {
+  if (cancelled_)
+    return;
+  bridge_->SetFirefoxSearchEnginesXMLData(search_engine_data);
+}
+
+#if defined(OS_WIN)
+void NetworkingPrivateProcessClient::OnIE7PasswordReceived(
+    const importer::ImporterIE7PasswordInfo& importer_password_info) {
+  if (cancelled_)
+    return;
+  bridge_->AddIE7PasswordInfo(importer_password_info);
+}
+#endif
+
+NetworkingPrivateProcessClient::~NetworkingPrivateProcessClient() {}
+
+void NetworkingPrivateProcessClient::Cleanup() {
+  if (cancelled_)
+    return;
+
+  if (process_importer_host_)
+    process_importer_host_->NotifyImportEnded();
+  Release();
+}
+
+void NetworkingPrivateProcessClient::CancelImportProcessOnIOThread() {
+  if (utility_process_host_.get())
+    utility_process_host_->Send(new ProfileImportProcessMsg_CancelImport());
+}
+
+void NetworkingPrivateProcessClient::NotifyItemFinishedOnIOThread(
+    importer::ImportItem import_item) {
+  utility_process_host_->Send(
+      new ProfileImportProcessMsg_ReportImportItemFinished(import_item));
+}
+
+void NetworkingPrivateProcessClient::StartProcessOnIOThread(
+    BrowserThread::ID thread_id) {
+  utility_process_host_ = UtilityProcessHost::Create(
+      this, BrowserThread::GetMessageLoopProxyForThread(thread_id).get())
+      ->AsWeakPtr();
+  utility_process_host_->DisableSandbox();
+
+#if defined(OS_MACOSX)
+  base::EnvironmentVector env;
+  std::string dylib_path = GetFirefoxDylibPath().value();
+  if (!dylib_path.empty())
+    env.push_back(std::make_pair("DYLD_FALLBACK_LIBRARY_PATH", dylib_path));
+  utility_process_host_->SetEnv(env);
+#endif
+
+  // Dictionary of all localized strings that could be needed by the importer
+  // in the external process.
+  DictionaryValue localized_strings;
+  localized_strings.SetString(
+      base::IntToString(IDS_BOOKMARK_GROUP),
+      l10n_util::GetStringUTF8(IDS_BOOKMARK_GROUP));
+  localized_strings.SetString(
+      base::IntToString(IDS_BOOKMARK_GROUP_FROM_FIREFOX),
+      l10n_util::GetStringUTF8(IDS_BOOKMARK_GROUP_FROM_FIREFOX));
+  localized_strings.SetString(
+      base::IntToString(IDS_BOOKMARK_GROUP_FROM_SAFARI),
+      l10n_util::GetStringUTF8(IDS_BOOKMARK_GROUP_FROM_SAFARI));
+  localized_strings.SetString(
+      base::IntToString(IDS_IMPORT_FROM_FIREFOX),
+      l10n_util::GetStringUTF8(IDS_IMPORT_FROM_FIREFOX));
+  localized_strings.SetString(
+      base::IntToString(IDS_IMPORT_FROM_ICEWEASEL),
+      l10n_util::GetStringUTF8(IDS_IMPORT_FROM_ICEWEASEL));
+  localized_strings.SetString(
+      base::IntToString(IDS_IMPORT_FROM_SAFARI),
+      l10n_util::GetStringUTF8(IDS_IMPORT_FROM_SAFARI));
+  localized_strings.SetString(
+      base::IntToString(IDS_BOOKMARK_BAR_FOLDER_NAME),
+      l10n_util::GetStringUTF8(IDS_BOOKMARK_BAR_FOLDER_NAME));
+
+  utility_process_host_->Send(new ProfileImportProcessMsg_StartImport(
+      source_profile_, items_, localized_strings));
+}
+
+*/