Remote Assistance on Chrome OS Part III - NativeMessageHost

chrome/browser/extensions/api/messaging/native_message_process_host.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/api/messaging/native_message_process_host.h"
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
-#include "base/prefs/pref_service.h"
 #include "base/process/kill.h"
 #include "base/threading/sequenced_worker_pool.h"
-#include "base/values.h"
 #include "chrome/browser/extensions/api/messaging/native_messaging_host_manifest.h"
 #include "chrome/browser/extensions/api/messaging/native_process_launcher.h"
 #include "chrome/common/chrome_version_info.h"
 #include "content/public/browser/browser_thread.h"
-#include "extensions/browser/pref_names.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/features/feature.h"
 #include "net/base/file_stream.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "url/gurl.h"
 
 namespace {
 
@@ skipping 15 matching lines @@
 const char kNotFoundError[] = "Specified native messaging host not found.";
 const char kForbiddenError[] =
     "Access to the specified native messaging host is forbidden.";
 const char kHostInputOuputError[] =
     "Error when communicating with the native messaging host.";
 
 }  // namespace
 
 namespace extensions {
 
-// static
-NativeMessageProcessHost::PolicyPermission
-NativeMessageProcessHost::IsHostAllowed(const PrefService* pref_service,
-                                        const std::string& native_host_name) {
-  NativeMessageProcessHost::PolicyPermission allow_result = ALLOW_ALL;
-  if (pref_service->IsManagedPreference(
-          pref_names::kNativeMessagingUserLevelHosts)) {
-    if (!pref_service->GetBoolean(pref_names::kNativeMessagingUserLevelHosts))
-      allow_result = ALLOW_SYSTEM_ONLY;
-  }
-
-  // All native messaging hosts are allowed if there is no blacklist.
-  if (!pref_service->IsManagedPreference(pref_names::kNativeMessagingBlacklist))
-    return allow_result;
-  const base::ListValue* blacklist =
-      pref_service->GetList(pref_names::kNativeMessagingBlacklist);
-  if (!blacklist)
-    return allow_result;
-
-  // Check if the name or the wildcard is in the blacklist.
-  base::StringValue name_value(native_host_name);
-  base::StringValue wildcard_value("*");
-  if (blacklist->Find(name_value) == blacklist->end() &&
-      blacklist->Find(wildcard_value) == blacklist->end()) {
-    return allow_result;
-  }
-
-  // The native messaging host is blacklisted. Check the whitelist.
-  if (pref_service->IsManagedPreference(
-          pref_names::kNativeMessagingWhitelist)) {
-    const base::ListValue* whitelist =
-        pref_service->GetList(pref_names::kNativeMessagingWhitelist);
-    if (whitelist && whitelist->Find(name_value) != whitelist->end())
-      return allow_result;
-  }
-
-  return DISALLOW;
-}
-
 NativeMessageProcessHost::NativeMessageProcessHost(
     base::WeakPtr<Client> weak_client_ui,
     const std::string& source_extension_id,
     const std::string& native_host_name,
     int destination_port,
     scoped_ptr<NativeProcessLauncher> launcher)
     : weak_client_ui_(weak_client_ui),
       source_extension_id_(source_extension_id),
       native_host_name_(native_host_name),
       destination_port_(destination_port),
@@ skipping 13 matching lines @@
       base::Bind(&NativeMessageProcessHost::LaunchHostProcess,
                  base::Unretained(this)));
 }
 
 NativeMessageProcessHost::~NativeMessageProcessHost() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   Close(std::string());
 }
 
 // static
-scoped_ptr<NativeMessageProcessHost> NativeMessageProcessHost::Create(
+scoped_ptr<NativeMessageHost> NativeMessageHost::Create(
     gfx::NativeView native_view,
     base::WeakPtr<Client> weak_client_ui,
     const std::string& source_extension_id,
     const std::string& native_host_name,
     int destination_port,
     bool allow_user_level) {
-  return CreateWithLauncher(weak_client_ui, source_extension_id,
-                            native_host_name, destination_port,
-                            NativeProcessLauncher::CreateDefault(
-                                allow_user_level, native_view));
+  return NativeMessageProcessHost::CreateWithLauncher(
+      weak_client_ui,
+      source_extension_id,
+      native_host_name,
+      destination_port,
+      NativeProcessLauncher::CreateDefault(allow_user_level, native_view));
 }
 
 // static
-scoped_ptr<NativeMessageProcessHost>
+scoped_ptr<NativeMessageHost>
 NativeMessageProcessHost::CreateWithLauncher(
     base::WeakPtr<Client> weak_client_ui,
     const std::string& source_extension_id,
     const std::string& native_host_name,
     int destination_port,
     scoped_ptr<NativeProcessLauncher> launcher) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
-  scoped_ptr<NativeMessageProcessHost> process(new NativeMessageProcessHost(
+  scoped_ptr<NativeMessageHost> process(new NativeMessageProcessHost(
       weak_client_ui, source_extension_id, native_host_name,
       destination_port, launcher.Pass()));
 
   return process.Pass();
 }
 
 void NativeMessageProcessHost::LaunchHostProcess() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
   GURL origin(std::string(kExtensionScheme) + "://" + source_extension_id_);
@@ skipping 162 matching lines @@
       LOG(ERROR) << "Native Messaging host tried sending a message that is "
                  << message_size << " bytes long.";
       Close(kHostInputOuputError);
       return;
     }
 
     if (incoming_data_.size() < message_size + kMessageHeaderSize)
       return;
 
     content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
-        base::Bind(&Client::PostMessageFromNativeProcess, weak_client_ui_,
+        base::Bind(&Client::PostMessageFromNative, weak_client_ui_,
             destination_port_,
             incoming_data_.substr(kMessageHeaderSize, message_size)));
 
     incoming_data_.erase(0, kMessageHeaderSize + message_size);
   }
 }
 
 void NativeMessageProcessHost::DoWrite() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
@@ skipping 62 matching lines @@
     content::BrowserThread::PostBlockingPoolTask(
         FROM_HERE, base::Bind(&base::EnsureProcessTerminated, process_handle_));
 #else
     base::EnsureProcessTerminated(process_handle_);
 #endif
     process_handle_ = base::kNullProcessHandle;
   }
 }
 
 }  // namespace extensions