The user's consent to crash dumps reporting can now be set via the UI (Windows only). The checkbox …

remoting/host/plugin/host_script_object.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 "remoting/host/plugin/host_script_object.h"
 
 #include "base/bind.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/message_loop.h"
@@ skipping 36 matching lines @@
 const char* kAttrNameOnStateChanged = "onStateChanged";
 const char* kFuncNameConnect = "connect";
 const char* kFuncNameDisconnect = "disconnect";
 const char* kFuncNameLocalize = "localize";
 const char* kFuncNameGetHostName = "getHostName";
 const char* kFuncNameGetPinHash = "getPinHash";
 const char* kFuncNameGenerateKeyPair = "generateKeyPair";
 const char* kFuncNameUpdateDaemonConfig = "updateDaemonConfig";
 const char* kFuncNameGetDaemonConfig = "getDaemonConfig";
 const char* kFuncNameGetDaemonVersion = "getDaemonVersion";
+const char* kFuncNameGetUsageStatsConsent = "getUsageStatsConsent";
 const char* kFuncNameStartDaemon = "startDaemon";
 const char* kFuncNameStopDaemon = "stopDaemon";
 
 // States.
 const char* kAttrNameDisconnected = "DISCONNECTED";
 const char* kAttrNameStarting = "STARTING";
 const char* kAttrNameRequestedAccessCode = "REQUESTED_ACCESS_CODE";
 const char* kAttrNameReceivedAccessCode = "RECEIVED_ACCESS_CODE";
 const char* kAttrNameConnected = "CONNECTED";
 const char* kAttrNameDisconnecting = "DISCONNECTING";
@@ skipping 89 matching lines @@
   CHECK_EQ(base::PlatformThread::CurrentId(), np_thread_id_);
   return (method_name == kFuncNameConnect ||
           method_name == kFuncNameDisconnect ||
           method_name == kFuncNameLocalize ||
           method_name == kFuncNameGetHostName ||
           method_name == kFuncNameGetPinHash ||
           method_name == kFuncNameGenerateKeyPair ||
           method_name == kFuncNameUpdateDaemonConfig ||
           method_name == kFuncNameGetDaemonConfig ||
           method_name == kFuncNameGetDaemonVersion ||
+          method_name == kFuncNameGetUsageStatsConsent ||
           method_name == kFuncNameStartDaemon ||
           method_name == kFuncNameStopDaemon);
 }
 
 bool HostNPScriptObject::InvokeDefault(const NPVariant* args,
                                        uint32_t arg_count,
                                        NPVariant* result) {
   VLOG(2) << "InvokeDefault";
   CHECK_EQ(base::PlatformThread::CurrentId(), np_thread_id_);
   SetException("exception during default invocation");
@@ skipping 17 matching lines @@
   } else if (method_name == kFuncNameGetPinHash) {
     return GetPinHash(args, arg_count, result);
   } else if (method_name == kFuncNameGenerateKeyPair) {
     return GenerateKeyPair(args, arg_count, result);
   } else if (method_name == kFuncNameUpdateDaemonConfig) {
     return UpdateDaemonConfig(args, arg_count, result);
   } else if (method_name == kFuncNameGetDaemonConfig) {
     return GetDaemonConfig(args, arg_count, result);
   } else if (method_name == kFuncNameGetDaemonVersion) {
     return GetDaemonVersion(args, arg_count, result);
+  } else if (method_name == kFuncNameGetUsageStatsConsent) {
+    return GetUsageStatsConsent(args, arg_count, result);
   } else if (method_name == kFuncNameStartDaemon) {
     return StartDaemon(args, arg_count, result);
   } else if (method_name == kFuncNameStopDaemon) {
     return StopDaemon(args, arg_count, result);
   } else {
     SetException("Invoke: unknown method " + method_name);
     return false;
   }
 }
 
@@ skipping 153 matching lines @@
     kAttrNameError,
     kFuncNameConnect,
     kFuncNameDisconnect,
     kFuncNameLocalize,
     kFuncNameGetHostName,
     kFuncNameGetPinHash,
     kFuncNameGenerateKeyPair,
     kFuncNameUpdateDaemonConfig,
     kFuncNameGetDaemonConfig,
     kFuncNameGetDaemonVersion,
+    kFuncNameGetUsageStatsConsent,
     kFuncNameStartDaemon,
     kFuncNameStopDaemon
   };
   for (size_t i = 0; i < arraysize(entries); ++i) {
     values->push_back(entries[i]);
   }
   return true;
 }
 
 void HostNPScriptObject::OnAccessDenied(const std::string& jid) {
@@ skipping 369 matching lines @@
 
   // We control lifetime of the |daemon_controller_| so it's safe to
   // use base::Unretained() here.
   daemon_controller_->GetVersion(
       base::Bind(&HostNPScriptObject::InvokeGetDaemonVersionCallback,
                  base::Unretained(this), callback_obj));
 
   return true;
 }
 
+bool HostNPScriptObject::GetUsageStatsConsent(const NPVariant* args,
+                                              uint32_t arg_count,
+                                              NPVariant* result) {
+  if (arg_count != 1) {
+    SetException("getUsageStatsConsent: bad number of arguments");
+    return false;
+  }
+
+  ScopedRefNPObject callback_obj(ObjectFromNPVariant(args[0]));
+  if (!callback_obj.get()) {
+    SetException("getUsageStatsConsent: invalid callback parameter");
+    return false;
+  }
+
+  // We control lifetime of the |daemon_controller_| so it's safe to
+  // use base::Unretained() here.
+  daemon_controller_->GetUsageStatsConsent(
+      base::Bind(&HostNPScriptObject::InvokeGetUsageStatsConsentCallback,
+                 base::Unretained(this), callback_obj));
+  return true;
+}
+
 bool HostNPScriptObject::StartDaemon(const NPVariant* args,
                                      uint32_t arg_count,
                                      NPVariant* result) {
-  if (arg_count != 2) {
+  if (arg_count != 3) {
     SetException("startDaemon: bad number of arguments");
     return false;
   }
 
   std::string config_str = StringFromNPVariant(args[0]);
   scoped_ptr<base::Value> config(
       base::JSONReader::Read(config_str, base::JSON_ALLOW_TRAILING_COMMAS));
   if (config_str.empty() || !config.get() ||
       !config->IsType(base::Value::TYPE_DICTIONARY)) {
-    SetException("updateDaemonConfig: bad config parameter");
+    SetException("startDaemon: bad config parameter");
     return false;
   }
   scoped_ptr<base::DictionaryValue> config_dict(
       reinterpret_cast<base::DictionaryValue*>(config.release()));
 
-  ScopedRefNPObject callback_obj(ObjectFromNPVariant(args[1]));
+  if (!NPVARIANT_IS_BOOLEAN(args[1])) {
+    SetException("startDaemon: invalid consent parameter");
+    return false;
+  }
+
+  ScopedRefNPObject callback_obj(ObjectFromNPVariant(args[2]));
   if (!callback_obj.get()) {
     SetException("startDaemon: invalid callback parameter");
     return false;
   }
 
   daemon_controller_->SetConfigAndStart(
       config_dict.Pass(),
+      NPVARIANT_TO_BOOLEAN(args[1]),
       base::Bind(&HostNPScriptObject::InvokeAsyncResultCallback,
                  base::Unretained(this), callback_obj));
   return true;
 }
 
 bool HostNPScriptObject::StopDaemon(const NPVariant* args,
                                     uint32_t arg_count,
                                     NPVariant* result) {
   if (arg_count != 1) {
     SetException("stopDaemon: bad number of arguments");
@@ skipping 333 matching lines @@
             &HostNPScriptObject::InvokeGetDaemonVersionCallback,
             base::Unretained(this), callback, version));
     return;
   }
 
   NPVariant version_val = NPVariantFromString(version);
   InvokeAndIgnoreResult(callback.get(), &version_val, 1);
   g_npnetscape_funcs->releasevariantvalue(&version_val);
 }
 
+void HostNPScriptObject::InvokeGetUsageStatsConsentCallback(
+    const ScopedRefNPObject& callback,
+    bool supported,
+    bool allowed,
+    bool set_by_policy) {
+  if (!plugin_message_loop_proxy_->BelongsToCurrentThread()) {
+    plugin_message_loop_proxy_->PostTask(
+        FROM_HERE, base::Bind(
+            &HostNPScriptObject::InvokeGetUsageStatsConsentCallback,
+            base::Unretained(this), callback, supported, allowed,
+            set_by_policy));
+    return;
+  }
+
+  NPVariant params[3];
+  BOOLEAN_TO_NPVARIANT(supported, params[0]);
+  BOOLEAN_TO_NPVARIANT(allowed, params[1]);
+  BOOLEAN_TO_NPVARIANT(set_by_policy, params[2]);
+  InvokeAndIgnoreResult(callback.get(), params, arraysize(params));
+  g_npnetscape_funcs->releasevariantvalue(&(params[0]));
+  g_npnetscape_funcs->releasevariantvalue(&(params[1]));
+  g_npnetscape_funcs->releasevariantvalue(&(params[2]));
+}
+
 void HostNPScriptObject::LogDebugInfo(const std::string& message) {
   DCHECK(plugin_message_loop_proxy_->BelongsToCurrentThread());
   if (log_debug_info_func_.get()) {
     am_currently_logging_ = true;
     NPVariant log_message;
     STRINGZ_TO_NPVARIANT(message.c_str(), log_message);
     bool is_good = InvokeAndIgnoreResult(log_debug_info_func_.get(),
                                          &log_message, 1);
     if (!is_good) {
       LOG(ERROR) << "ERROR - LogDebugInfo failed\n";
@@ skipping 14 matching lines @@
   return is_good;
 }
 
 void HostNPScriptObject::SetException(const std::string& exception_string) {
   DCHECK(plugin_message_loop_proxy_->BelongsToCurrentThread());
   g_npnetscape_funcs->setexception(parent_, exception_string.c_str());
   LOG(INFO) << exception_string;
 }
 
 }  // namespace remoting