Vibration API : migrate to device/vibration using mojo.

device/vibration/vibration_manager_impl.cc

Index: device/vibration/vibration_manager_impl.cc
diff --git a/device/vibration/vibration_manager_impl.cc b/device/vibration/vibration_manager_impl.cc
new file mode 100644
index 0000000000000000000000000000000000000000..cf4c1afba5a3cacc68abc1eea8ea5a77d683977d
--- /dev/null
+++ b/device/vibration/vibration_manager_impl.cc
@@ -0,0 +1,61 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.

[qsr, 2014/09/29 08:39:14]

Hum... Do we need this class at all. It seems that its main purpose is to allow
to override the provider. Shouldn't we have a point of extension at registration
time instead? Anyone that would want to override the service would just register
another implementation. The way it works today, the last registration win. So if
the point of extension is the last thing we do, we give the full control on the
set of available service and their implementation, and we do not need this class
at all.

[blundell, 2014/09/29 09:13:49]

+1. We should be providing an interface for the content client to register any
services it wants to. This will happen after //content registers its own
services. The downstream project can then just provide their own service impl
and register it.

[Michael van Ouwerkerk, 2014/09/29 12:55:20]

Why override after content registers its own services? Sound like potentially
redundant work. We should override before.

[timvolodine, 2014/10/03 15:57:14]

I agree this looks like a good example since vibration api is currently
java-only and we can probably get rid of this class. I think this is best
handled in a separate follow-up patch though, since we don't have a proper mojo
override interface yet. This patch is intended for migration to mojo + moving to
device/vibration.

+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "device/vibration/vibration_manager_impl.h"
+
+#include "base/bind.h"
+#include "device/vibration/vibration_provider.h"
+
+namespace device {
+
+namespace {
+VibrationProvider* g_provider_override = NULL;
+const int64 kMinimumVibrationDurationMs = 1;  // 1 millisecond
+const int64 kMaximumVibrationDurationMs = 10000;  // 10 seconds
+}
+
+//static
+void VibrationManagerImpl::Create(
+    mojo::InterfaceRequest<VibrationManager> request) {
+  BindToRequest(new VibrationManagerImpl(), &request);
+}
+
+VibrationManagerImpl::VibrationManagerImpl()
+    : provider_(g_provider_override ? g_provider_override : CreateProvider()) {
+}
+
+VibrationManagerImpl::~VibrationManagerImpl() {
+}
+
+void VibrationManagerImpl::Vibrate(int64 millis) {
+  if (!provider_)
+    return;
+
+  // Though the Blink implementation already sanitizes vibration times, don't
+  // trust any values passed from the renderer.
+  int64 milliseconds = std::max(kMinimumVibrationDurationMs,
+                                std::min(millis, kMaximumVibrationDurationMs));
+
+  provider_->Vibrate(milliseconds);
+}
+
+void VibrationManagerImpl::Cancel() {
+  if (provider_)
+    provider_->CancelVibration();
+}
+
+#if !defined(OS_ANDROID)
+// static
+VibrationProvider* VibrationManagerImpl::CreateProvider() {
+  return NULL;
+}
+#endif
+
+// static
+void VibrationManagerImpl::SetOverrideVibrationProvider(
+    VibrationProvider* provider) {
+  g_provider_override = provider;
+}
+
+}  // namespace device