Change webcamPrivate.set/get/reset to async APIs.

extensions/browser/api/webcam_private/webcam_private_api_chromeos.cc

 // Copyright 2014 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 "extensions/browser/api/webcam_private/webcam_private_api.h"
 
 #include "base/lazy_instance.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/media_device_id.h"
 #include "content/public/browser/resource_context.h"
 #include "extensions/browser/api/webcam_private/v4l2_webcam.h"
 #include "extensions/browser/api/webcam_private/visca_webcam.h"
 #include "extensions/browser/process_manager.h"
 #include "extensions/browser/process_manager_factory.h"
 #include "extensions/common/api/webcam_private.h"
 
 namespace webcam_private = extensions::api::webcam_private;
 
 namespace content {
 class BrowserContext;
 }  // namespace content
 
 namespace {
+
 const char kPathInUse[] = "Path in use";
 const char kUnknownWebcam[] = "Unknown webcam id";
+const char kGetWebcamPTZError[] = "Can't get web camera pan/tilt/zoom.";
+const char kSetWebcamPTZError[] = "Can't set web camera pan/tilt/zoom.";
+const char kResetWebcamError[] = "Can't reset web camera.";
+
 }  // namespace
 
 namespace extensions {
 
 // static
 WebcamPrivateAPI* WebcamPrivateAPI::Get(content::BrowserContext* context) {
   return GetFactoryInstance()->Get(context);
 }
 
 WebcamPrivateAPI::WebcamPrivateAPI(content::BrowserContext* context)
@@ skipping 181 matching lines @@
   return WebcamPrivateAPI::Get(browser_context())
       ->CloseWebcam(extension_id(), params->webcam_id);
 }
 
 WebcamPrivateSetFunction::WebcamPrivateSetFunction() {
 }
 
 WebcamPrivateSetFunction::~WebcamPrivateSetFunction() {
 }
 
-bool WebcamPrivateSetFunction::RunSync() {
+bool WebcamPrivateSetFunction::RunAsync() {
   scoped_ptr<webcam_private::Set::Params> params(
       webcam_private::Set::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   Webcam* webcam = WebcamPrivateAPI::Get(browser_context())
                        ->GetWebcam(extension_id(), params->webcam_id);
   if (!webcam) {
     SetError(kUnknownWebcam);
     return false;
   }
 
   if (params->config.pan) {
-    webcam->SetPan(*(params->config.pan));
+    webcam->SetPan(
+        *(params->config.pan),
+        base::Bind(&WebcamPrivateSetFunction::OnSetWebcamParameters, this));
   }
 
   if (params->config.pan_direction) {
     Webcam::PanDirection direction = Webcam::PAN_STOP;
     switch (params->config.pan_direction) {
       case webcam_private::PAN_DIRECTION_NONE:
       case webcam_private::PAN_DIRECTION_STOP:
         direction = Webcam::PAN_STOP;
         break;
 
       case webcam_private::PAN_DIRECTION_RIGHT:
         direction = Webcam::PAN_RIGHT;
         break;
 
       case webcam_private::PAN_DIRECTION_LEFT:
         direction = Webcam::PAN_LEFT;
         break;
     }
-    webcam->SetPanDirection(direction);
+    webcam->SetPanDirection(
+        direction,
+        base::Bind(&WebcamPrivateSetFunction::OnSetWebcamParameters, this));
   }
 
   if (params->config.tilt) {
-    webcam->SetTilt(*(params->config.tilt));
+    webcam->SetTilt(
+        *(params->config.tilt),
+        base::Bind(&WebcamPrivateSetFunction::OnSetWebcamParameters, this));
   }
 
   if (params->config.tilt_direction) {
     Webcam::TiltDirection direction = Webcam::TILT_STOP;
     switch (params->config.tilt_direction) {
       case webcam_private::TILT_DIRECTION_NONE:
       case webcam_private::TILT_DIRECTION_STOP:
         direction = Webcam::TILT_STOP;
         break;
 
       case webcam_private::TILT_DIRECTION_UP:
         direction = Webcam::TILT_UP;
         break;
 
       case webcam_private::TILT_DIRECTION_DOWN:
         direction = Webcam::TILT_DOWN;
         break;
     }
-    webcam->SetTiltDirection(direction);
+    webcam->SetTiltDirection(
+        direction,
+        base::Bind(&WebcamPrivateSetFunction::OnSetWebcamParameters, this));
   }
 
   if (params->config.zoom) {
-    webcam->SetZoom(*(params->config.zoom));
+    webcam->SetZoom(
+        *(params->config.zoom),
+        base::Bind(&WebcamPrivateSetFunction::OnSetWebcamParameters, this));
   }
 
-
   return true;
 }
 
-WebcamPrivateGetFunction::WebcamPrivateGetFunction() {
+void WebcamPrivateSetFunction::OnSetWebcamParameters(bool success) {
+  if (!success)
+    SetError(kSetWebcamPTZError);
 }
 
+WebcamPrivateGetFunction::WebcamPrivateGetFunction()
+    : pan_(0), tilt_(0), zoom_(0), success_(true) {}
+
 WebcamPrivateGetFunction::~WebcamPrivateGetFunction() {
 }
 
-bool WebcamPrivateGetFunction::RunSync() {
+bool WebcamPrivateGetFunction::RunAsync() {
   scoped_ptr<webcam_private::Get::Params> params(
       webcam_private::Get::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   Webcam* webcam = WebcamPrivateAPI::Get(browser_context())
                        ->GetWebcam(extension_id(), params->webcam_id);
   if (!webcam) {
     SetError(kUnknownWebcam);
     return false;
   }
 
-  webcam_private::WebcamConfiguration result;
-
-  int pan;
-  if (webcam->GetPan(&pan))
-    result.pan.reset(new double(pan));
-
-  int tilt;
-  if (webcam->GetTilt(&tilt))
-    result.tilt.reset(new double(tilt));
-
-  int zoom;
-  if (webcam->GetZoom(&zoom))
-    result.zoom.reset(new double(zoom));
-
-  SetResult(result.ToValue().release());
+  webcam->GetPan(base::Bind(&WebcamPrivateGetFunction::OnGetWebcamParameters,
+                            this, INQUIRY_PAN));
+  webcam->GetTilt(base::Bind(&WebcamPrivateGetFunction::OnGetWebcamParameters,
+                             this, INQUIRY_TILT));
+  webcam->GetZoom(base::Bind(&WebcamPrivateGetFunction::OnGetWebcamParameters,
+                             this, INQUIRY_ZOOM));
 
   return true;
 }
 
+void WebcamPrivateGetFunction::OnGetWebcamParameters(InquiryType type,
+                                                     bool success,
+                                                     int value) {
+  if (!success_)
+    return;
+  success_ &= success;

[Zachary Kuznia, 2015/08/26 23:31:13]

You shouldn't use bitwise AND for bools.

+
+  if (!success_) {
+    SetError(kGetWebcamPTZError);
+    SendResponse(false);
+  } else {
+    switch (type) {
+      case INQUIRY_PAN:
+        pan_ = value;
+        break;
+      case INQUIRY_TILT:
+        tilt_ = value;
+        break;
+      case INQUIRY_ZOOM:
+        zoom_ = value;
+        webcam_private::WebcamConfiguration result;

[Zachary Kuznia, 2015/08/26 23:31:13]

You shouldn't assume that async functions are invoked in order.  Instead, track
which ones have completed, and set the result when all three have finished.

+        result.pan.reset(new double(pan_));
+        result.tilt.reset(new double(tilt_));
+        result.zoom.reset(new double(zoom_));
+        SetResult(result.ToValue().release());
+        SendResponse(true);
+        break;
+    }
+  }
+}
+
 WebcamPrivateResetFunction::WebcamPrivateResetFunction() {
 }
 
 WebcamPrivateResetFunction::~WebcamPrivateResetFunction() {
 }
 
-bool WebcamPrivateResetFunction::RunSync() {
+bool WebcamPrivateResetFunction::RunAsync() {
   scoped_ptr<webcam_private::Reset::Params> params(
       webcam_private::Reset::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   Webcam* webcam = WebcamPrivateAPI::Get(browser_context())
                        ->GetWebcam(extension_id(), params->webcam_id);
   if (!webcam) {
     SetError(kUnknownWebcam);
     return false;
   }
 
-  webcam->Reset(params->config.pan, params->config.tilt, params->config.zoom);
+  webcam->Reset(params->config.pan, params->config.tilt, params->config.zoom,
+                base::Bind(&WebcamPrivateResetFunction::OnResetWebcam, this));
 
   return true;
 }
 
+void WebcamPrivateResetFunction::OnResetWebcam(bool success) {
+  if (!success)
+    SetError(kResetWebcamError);
+}
+
 static base::LazyInstance<BrowserContextKeyedAPIFactory<WebcamPrivateAPI>>
     g_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserContextKeyedAPIFactory<WebcamPrivateAPI>*
 WebcamPrivateAPI::GetFactoryInstance() {
   return g_factory.Pointer();
 }
 
 template <>
 void BrowserContextKeyedAPIFactory<WebcamPrivateAPI>
     ::DeclareFactoryDependencies() {
   DependsOn(ExtensionsBrowserClient::Get()->GetExtensionSystemFactory());
   DependsOn(ProcessManagerFactory::GetInstance());
 }
 
 }  // namespace extensions