The Tor Browser: dom/camera/GonkCameraParameters.cpp@129ffea94266 (annotated)

dom/camera/GonkCameraParameters.cpp@129ffea94266 (annotated)

dom/camera/GonkCameraParameters.cpp

Sat, 03 Jan 2015 20:18:00 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Sat, 03 Jan 2015 20:18:00 +0100
branch: TOR_BUG_3246
changeset 7: 129ffea94266
permissions: -rw-r--r--

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

 /*
  * Copyright (C) 2013-2014 Mozilla Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 #include "GonkCameraParameters.h"
 #include "camera/CameraParameters.h"
 #include "ICameraControl.h"
 #include "CameraCommon.h"
 using namespace mozilla;
 using namespace android;
 /* static */ const char*
 GonkCameraParameters::Parameters::GetTextKey(uint32_t aKey)
 {
   switch (aKey) {
     case CAMERA_PARAM_PREVIEWSIZE:
       return KEY_PREVIEW_SIZE;
     case CAMERA_PARAM_PREVIEWFORMAT:
       return KEY_PREVIEW_FORMAT;
     case CAMERA_PARAM_PREVIEWFRAMERATE:
       return KEY_PREVIEW_FRAME_RATE;
     case CAMERA_PARAM_EFFECT:
       return KEY_EFFECT;
     case CAMERA_PARAM_WHITEBALANCE:
       return KEY_WHITE_BALANCE;
     case CAMERA_PARAM_SCENEMODE:
       return KEY_SCENE_MODE;
     case CAMERA_PARAM_FLASHMODE:
       return KEY_FLASH_MODE;
     case CAMERA_PARAM_FOCUSMODE:
       return KEY_FOCUS_MODE;
     case CAMERA_PARAM_ZOOM:
       return KEY_ZOOM;
     case CAMERA_PARAM_METERINGAREAS:
       return KEY_METERING_AREAS;
     case CAMERA_PARAM_FOCUSAREAS:
       return KEY_FOCUS_AREAS;
     case CAMERA_PARAM_FOCALLENGTH:
       return KEY_FOCAL_LENGTH;
     case CAMERA_PARAM_FOCUSDISTANCENEAR:
       return KEY_FOCUS_DISTANCES;
     case CAMERA_PARAM_FOCUSDISTANCEOPTIMUM:
       return KEY_FOCUS_DISTANCES;
     case CAMERA_PARAM_FOCUSDISTANCEFAR:
       return KEY_FOCUS_DISTANCES;
     case CAMERA_PARAM_EXPOSURECOMPENSATION:
       return KEY_EXPOSURE_COMPENSATION;
     case CAMERA_PARAM_THUMBNAILQUALITY:
       return KEY_JPEG_THUMBNAIL_QUALITY;
     case CAMERA_PARAM_PICTURE_SIZE:
       return KEY_PICTURE_SIZE;
     case CAMERA_PARAM_PICTURE_FILEFORMAT:
       return KEY_PICTURE_FORMAT;
     case CAMERA_PARAM_PICTURE_ROTATION:
       return KEY_ROTATION;
     case CAMERA_PARAM_PICTURE_DATETIME:
       // Not every platform defines a KEY_EXIF_DATETIME;
       // for those that don't, we use the raw string key, and if the platform
       // doesn't support it, it will be ignored.
       //
       // See bug 832494.
       return "exif-datetime";
     case CAMERA_PARAM_VIDEOSIZE:
       return KEY_VIDEO_SIZE;
     case CAMERA_PARAM_ISOMODE:
       // Not every platform defines KEY_ISO_MODE;
       // for those that don't, we use the raw string key.
       return "iso";
     case CAMERA_PARAM_LUMINANCE:
       return "luminance-condition";
     case CAMERA_PARAM_SCENEMODE_HDR_RETURNNORMALPICTURE:
       // Not every platform defines KEY_QC_HDR_NEED_1X;
       // for those that don't, we use the raw string key.
       return "hdr-need-1x";
     case CAMERA_PARAM_SUPPORTED_PREVIEWSIZES:
       return KEY_SUPPORTED_PREVIEW_SIZES;
     case CAMERA_PARAM_SUPPORTED_PICTURESIZES:
       return KEY_SUPPORTED_PICTURE_SIZES;
     case CAMERA_PARAM_SUPPORTED_VIDEOSIZES:
       return KEY_SUPPORTED_VIDEO_SIZES;
     case CAMERA_PARAM_SUPPORTED_PICTUREFORMATS:
       return KEY_SUPPORTED_PICTURE_FORMATS;
     case CAMERA_PARAM_SUPPORTED_WHITEBALANCES:
       return KEY_SUPPORTED_WHITE_BALANCE;
     case CAMERA_PARAM_SUPPORTED_SCENEMODES:
       return KEY_SUPPORTED_SCENE_MODES;
     case CAMERA_PARAM_SUPPORTED_EFFECTS:
       return KEY_SUPPORTED_EFFECTS;
     case CAMERA_PARAM_SUPPORTED_FLASHMODES:
       return KEY_SUPPORTED_FLASH_MODES;
     case CAMERA_PARAM_SUPPORTED_FOCUSMODES:
       return KEY_SUPPORTED_FOCUS_MODES;
     case CAMERA_PARAM_SUPPORTED_MAXFOCUSAREAS:
       return KEY_MAX_NUM_FOCUS_AREAS;
     case CAMERA_PARAM_SUPPORTED_MAXMETERINGAREAS:
       return KEY_MAX_NUM_METERING_AREAS;
     case CAMERA_PARAM_SUPPORTED_MINEXPOSURECOMPENSATION:
       return KEY_MIN_EXPOSURE_COMPENSATION;
     case CAMERA_PARAM_SUPPORTED_MAXEXPOSURECOMPENSATION:
       return KEY_MAX_EXPOSURE_COMPENSATION;
     case CAMERA_PARAM_SUPPORTED_EXPOSURECOMPENSATIONSTEP:
       return KEY_EXPOSURE_COMPENSATION_STEP;
     case CAMERA_PARAM_SUPPORTED_ZOOM:
       return KEY_ZOOM_SUPPORTED;
     case CAMERA_PARAM_SUPPORTED_ZOOMRATIOS:
       return KEY_ZOOM_RATIOS;
     case CAMERA_PARAM_SUPPORTED_MAXDETECTEDFACES:
       return KEY_MAX_NUM_DETECTED_FACES_HW;
     case CAMERA_PARAM_SUPPORTED_JPEG_THUMBNAIL_SIZES:
       return KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES;
     case CAMERA_PARAM_SUPPORTED_ISOMODES:
       // Not every platform defines KEY_SUPPORTED_ISO_MODES;
       // for those that don't, we use the raw string key.
       return "iso-values";
     default:
       DOM_CAMERA_LOGE("Unhandled camera parameter value %u\n", aKey);
       return nullptr;
   }
 }
 GonkCameraParameters::GonkCameraParameters()
   : mLock(PR_NewRWLock(PR_RWLOCK_RANK_NONE, "GonkCameraParameters.Lock"))
   , mDirty(false)
   , mInitialized(false)
 {
   MOZ_COUNT_CTOR(GonkCameraParameters);
   if (!mLock) {
     MOZ_CRASH("OOM getting new PRRWLock");
   }
 }
 GonkCameraParameters::~GonkCameraParameters()
 {
   MOZ_COUNT_DTOR(GonkCameraParameters);
   if (mLock) {
     PR_DestroyRWLock(mLock);
     mLock = nullptr;
   }
 }
 nsresult
 GonkCameraParameters::MapIsoToGonk(const nsAString& aIso, nsACString& aIsoOut)
 {
   if (aIso.EqualsASCII("hjr")) {
     aIsoOut = "ISO_HJR";
   } else if (aIso.EqualsASCII("auto")) {
     aIsoOut = "auto";
   } else {
     nsAutoCString v = NS_LossyConvertUTF16toASCII(aIso);
     unsigned int iso;
     if (sscanf(v.get(), "%u", &iso) != 1) {
       return NS_ERROR_FAILURE;
     }
     aIsoOut = nsPrintfCString("ISO%u", iso);
   }
   return NS_OK;
 }
 nsresult
 GonkCameraParameters::MapIsoFromGonk(const char* aIso, nsAString& aIsoOut)
 {
   if (strcmp(aIso, "ISO_HJR") == 0) {
     aIsoOut.AssignASCII("hjr");
   } else if (strcmp(aIso, "auto") == 0) {
     aIsoOut.AssignASCII("auto");
   } else {
     unsigned int iso;
     if (sscanf(aIso, "ISO%u", &iso) != 1) {
       return NS_ERROR_FAILURE;
     }
     aIsoOut.AppendInt(iso);
   }
   return NS_OK;
 }
 // Any members that need to be initialized on the first parameter pull
 // need to get handled in here.
 nsresult
 GonkCameraParameters::Initialize()
 {
   nsresult rv;
   rv = GetImpl(CAMERA_PARAM_SUPPORTED_MINEXPOSURECOMPENSATION, mExposureCompensationMin);
   if (NS_FAILED(rv)) {
     NS_WARNING("Failed to initialize minimum exposure compensation");
     mExposureCompensationMin = 0;
   }
   rv = GetImpl(CAMERA_PARAM_SUPPORTED_EXPOSURECOMPENSATIONSTEP, mExposureCompensationStep);
   if (NS_FAILED(rv)) {
     NS_WARNING("Failed to initialize exposure compensation step size");
     mExposureCompensationStep = 0;
   }
   rv = GetListAsArray(CAMERA_PARAM_SUPPORTED_ZOOMRATIOS, mZoomRatios);
   if (NS_FAILED(rv)) {
     // zoom is not supported
     mZoomRatios.Clear();
   }
   for (uint32_t i = 1; i < mZoomRatios.Length(); ++i) {
     // Make sure the camera gave us a properly sorted zoom ratio list!
     if (mZoomRatios[i] < mZoomRatios[i - 1]) {
       NS_WARNING("Zoom ratios list is out of order, discarding");
       DOM_CAMERA_LOGE("zoom[%d]=%fx < zoom[%d]=%fx is out of order\n",
         i, mZoomRatios[i] / 100.0, i - 1, mZoomRatios[i - 1] / 100.0);
       mZoomRatios.Clear();
       break;
     }
   }
   if (mZoomRatios.Length() == 0) {
     // Always report that we support at least 1.0x zoom.
     *mZoomRatios.AppendElement() = 100;
   }
   // The return code from GetListAsArray() doesn't matter. If it fails,
   // the isoModes array will be empty, and the subsequent loop won't
   // execute.
   nsTArray<nsCString> isoModes;
   GetListAsArray(CAMERA_PARAM_SUPPORTED_ISOMODES, isoModes);
   for (uint32_t i = 0; i < isoModes.Length(); ++i) {
     nsString v;
     rv = MapIsoFromGonk(isoModes[i].get(), v);
     if (NS_SUCCEEDED(rv)) {
       *mIsoModes.AppendElement() = v;
     }
   }
   mInitialized = true;
   return NS_OK;
 }
 // Handle nsAStrings
 nsresult
 GonkCameraParameters::SetTranslated(uint32_t aKey, const nsAString& aValue)
 {
   if (aKey == CAMERA_PARAM_ISOMODE) {
     nsAutoCString v;
     nsresult rv = MapIsoToGonk(aValue, v);
     if (NS_FAILED(rv)) {
       return rv;
     }
     return SetImpl(aKey, v.get());
   }
   return SetImpl(aKey, NS_ConvertUTF16toUTF8(aValue).get());
 }
 nsresult
 GonkCameraParameters::GetTranslated(uint32_t aKey, nsAString& aValue)
 {
   const char* val;
   nsresult rv = GetImpl(aKey, val);
   if (NS_FAILED(rv)) {
     return rv;
   }
   if (aKey == CAMERA_PARAM_ISOMODE) {
     rv = MapIsoFromGonk(val, aValue);
   } else if(val) {
     aValue.AssignASCII(val);
   } else {
     aValue.Truncate(0);
   }
   return rv;
 }
 // Handle ICameraControl::Sizes
 nsresult
 GonkCameraParameters::SetTranslated(uint32_t aKey, const ICameraControl::Size& aSize)
 {
   if (aSize.width > INT_MAX || aSize.height > INT_MAX) {
     // AOSP can only handle signed ints.
     DOM_CAMERA_LOGE("Camera parameter aKey=%d out of bounds (width=%u, height=%u)\n",
       aSize.width, aSize.height);
     return NS_ERROR_INVALID_ARG;
   }
   nsresult rv;
   switch (aKey) {
     case CAMERA_PARAM_THUMBNAILSIZE:
       // This is a special case--for some reason the thumbnail size
       // is accessed as two separate values instead of a tuple.
       // XXXmikeh - make this restore the original values on error
       rv = SetImpl(Parameters::KEY_JPEG_THUMBNAIL_WIDTH, static_cast<int>(aSize.width));
       if (NS_SUCCEEDED(rv)) {
         rv = SetImpl(Parameters::KEY_JPEG_THUMBNAIL_HEIGHT, static_cast<int>(aSize.height));
       }
       break;
     case CAMERA_PARAM_VIDEOSIZE:
       // "record-size" is probably deprecated in later ICS;
       // might need to set "video-size" instead of "record-size";
       // for the time being, set both. See bug 795332.
       rv = SetImpl("record-size", nsPrintfCString("%ux%u", aSize.width, aSize.height).get());
       if (NS_FAILED(rv)) {
         break;
       }
       // intentional fallthrough
     default:
       rv = SetImpl(aKey, nsPrintfCString("%ux%u", aSize.width, aSize.height).get());
       break;
   }
   if (NS_FAILED(rv)) {
     DOM_CAMERA_LOGE("Camera parameter aKey=%d failed to set (0x%x)\n", aKey, rv);
   }
   return rv;
 }
 nsresult
 GonkCameraParameters::GetTranslated(uint32_t aKey, ICameraControl::Size& aSize)
 {
   nsresult rv;
   if (aKey == CAMERA_PARAM_THUMBNAILSIZE) {
     int width;
     int height;
     rv = GetImpl(Parameters::KEY_JPEG_THUMBNAIL_WIDTH, width);
     if (NS_FAILED(rv) || width < 0) {
       return NS_ERROR_FAILURE;
     }
     rv = GetImpl(Parameters::KEY_JPEG_THUMBNAIL_HEIGHT, height);
     if (NS_FAILED(rv) || height < 0) {
       return NS_ERROR_FAILURE;
     }
     aSize.width = static_cast<uint32_t>(width);
     aSize.height = static_cast<uint32_t>(height);
     return NS_OK;
   }
   const char* value;
   rv = GetImpl(aKey, value);
   if (NS_FAILED(rv) || !value || *value == '\0') {
     DOM_CAMERA_LOGW("Camera parameter aKey=%d not available (0x%x)\n", aKey, rv);
     return NS_ERROR_NOT_AVAILABLE;
   }
   if (sscanf(value, "%ux%u", &aSize.width, &aSize.height) != 2) {
     DOM_CAMERA_LOGE("Camera parameter aKey=%d size tuple '%s' is invalid\n", aKey, value);
     return NS_ERROR_FAILURE;
   }
   return NS_OK;
 }
 // Handle arrays of ICameraControl::Regions
 nsresult
 GonkCameraParameters::SetTranslated(uint32_t aKey, const nsTArray<ICameraControl::Region>& aRegions)
 {
   uint32_t length = aRegions.Length();
   if (!length) {
     // This tells the camera driver to revert to automatic regioning.
     return SetImpl(aKey, "(0,0,0,0,0)");
   }
   nsCString s;
   for (uint32_t i = 0; i < length; ++i) {
     const ICameraControl::Region* r = &aRegions[i];
     s.AppendPrintf("(%d,%d,%d,%d,%d),", r->top, r->left, r->bottom, r->right, r->weight);
   }
   // remove the trailing comma
   s.Trim(",", false, true, true);
   return SetImpl(aKey, s.get());
 }
 nsresult
 GonkCameraParameters::GetTranslated(uint32_t aKey, nsTArray<ICameraControl::Region>& aRegions)
 {
   aRegions.Clear();
   const char* value;
   nsresult rv = GetImpl(aKey, value);
   if (NS_FAILED(rv) || !value || *value == '\0') {
     return NS_ERROR_FAILURE;
   }
   const char* p = value;
   uint32_t count = 1;
   // count the number of regions in the string
   while ((p = strstr(p, "),("))) {
     ++count;
     p += 3;
   }
   aRegions.SetCapacity(count);
   ICameraControl::Region* r;
   // parse all of the region sets
   uint32_t i;
   for (i = 0, p = value; p && i < count; ++i, p = strchr(p + 1, '(')) {
     r = aRegions.AppendElement();
     if (sscanf(p, "(%d,%d,%d,%d,%u)", &r->top, &r->left, &r->bottom, &r->right, &r->weight) != 5) {
       DOM_CAMERA_LOGE("%s:%d : region tuple has bad format: '%s'\n", __func__, __LINE__, p);
       aRegions.Clear();
       return NS_ERROR_FAILURE;
     }
   }
   return NS_OK;
 }
 // Handle ICameraControl::Positions
 nsresult
 GonkCameraParameters::SetTranslated(uint32_t aKey, const ICameraControl::Position& aPosition)
 {
   MOZ_ASSERT(aKey == CAMERA_PARAM_PICTURE_LOCATION);
   // Add any specified location information -- we don't care if these fail.
   if (!isnan(aPosition.latitude)) {
     DOM_CAMERA_LOGI("setting picture latitude to %lf\n", aPosition.latitude);
     SetImpl(Parameters::KEY_GPS_LATITUDE, nsPrintfCString("%lf", aPosition.latitude).get());
   }
   if (!isnan(aPosition.longitude)) {
     DOM_CAMERA_LOGI("setting picture longitude to %lf\n", aPosition.longitude);
     SetImpl(Parameters::KEY_GPS_LONGITUDE, nsPrintfCString("%lf", aPosition.longitude).get());
   }
   if (!isnan(aPosition.altitude)) {
     DOM_CAMERA_LOGI("setting picture altitude to %lf\n", aPosition.altitude);
     SetImpl(Parameters::KEY_GPS_ALTITUDE, nsPrintfCString("%lf", aPosition.altitude).get());
   }
   if (!isnan(aPosition.timestamp)) {
     DOM_CAMERA_LOGI("setting picture timestamp to %lf\n", aPosition.timestamp);
     SetImpl(Parameters::KEY_GPS_TIMESTAMP, nsPrintfCString("%lf", aPosition.timestamp).get());
   }
   return NS_OK;
 }
 // Handle int64_ts
 nsresult
 GonkCameraParameters::SetTranslated(uint32_t aKey, const int64_t& aValue)
 {
   switch (aKey) {
     case CAMERA_PARAM_PICTURE_DATETIME:
       {
         // Add the non-GPS timestamp.  The EXIF date/time field is formatted as
         // "YYYY:MM:DD HH:MM:SS", without room for a time-zone; as such, the time
         // is meant to be stored as a local time.  Since we are given seconds from
         // Epoch GMT, we use localtime_r() to handle the conversion.
         time_t time = aValue;
         if (time != aValue) {
           DOM_CAMERA_LOGE("picture date/time '%llu' is too far in the future\n", aValue);
           return NS_ERROR_INVALID_ARG;
         }
         struct tm t;
         if (!localtime_r(&time, &t)) {
           DOM_CAMERA_LOGE("picture date/time couldn't be converted to local time: (%d) %s\n", errno, strerror(errno));
           return NS_ERROR_FAILURE;
         }
         char dateTime[20];
         if (!strftime(dateTime, sizeof(dateTime), "%Y:%m:%d %T", &t)) {
           DOM_CAMERA_LOGE("picture date/time couldn't be converted to string\n");
           return NS_ERROR_FAILURE;
         }
         DOM_CAMERA_LOGI("setting picture date/time to %s\n", dateTime);
         return SetImpl(CAMERA_PARAM_PICTURE_DATETIME, dateTime);
       }
     case CAMERA_PARAM_ISOMODE:
       {
         if (aValue > INT32_MAX) {
           DOM_CAMERA_LOGW("Can't set ISO mode = %lld, too big\n", aValue);
           return NS_ERROR_INVALID_ARG;
         }
         nsString s;
         s.AppendInt(aValue);
         return SetTranslated(CAMERA_PARAM_ISOMODE, s);
       }
   }
   // You can't actually pass 64-bit parameters to Gonk. :(
   int32_t v = static_cast<int32_t>(aValue);
   if (static_cast<int64_t>(v) != aValue) {
     return NS_ERROR_INVALID_ARG;;
   }
   return SetImpl(aKey, v);
 }
 nsresult
 GonkCameraParameters::GetTranslated(uint32_t aKey, int64_t& aValue)
 {
   int val;
   nsresult rv = GetImpl(aKey, val);
   if (NS_FAILED(rv)) {
     return rv;
   }
   aValue = val;
   return NS_OK;
 }
 // Handle doubles
 nsresult
 GonkCameraParameters::SetTranslated(uint32_t aKey, const double& aValue)
 {
   int index;
   int value;
   switch (aKey) {
     case CAMERA_PARAM_EXPOSURECOMPENSATION:
       if (mExposureCompensationStep == 0) {
         DOM_CAMERA_LOGE("Exposure compensation not supported, can't set %f\n", aValue);
         return NS_ERROR_NOT_AVAILABLE;
       }
       /**
        * Convert from real value to a Gonk index, round
        * to the nearest step; index is 1-based.
        */
       index =
         (aValue - mExposureCompensationMin + mExposureCompensationStep / 2) /
         mExposureCompensationStep + 1;
       DOM_CAMERA_LOGI("Exposure compensation = %f --> index = %d\n", aValue, index);
       return SetImpl(CAMERA_PARAM_EXPOSURECOMPENSATION, index);
     case CAMERA_PARAM_ZOOM:
       {
         /**
          * Convert from a real zoom multipler (e.g. 2.5x) to
          * the index of the nearest supported value.
          */
         value = aValue * 100.0;
         if (value <= mZoomRatios[0]) {
           index = 0;
         } else if (value >= mZoomRatios.LastElement()) {
           index = mZoomRatios.Length() - 1;
         } else {
           // mZoomRatios is sorted, so we can binary search it
           int bottom = 0;
           int top = mZoomRatios.Length() - 1;
           while (top >= bottom) {
             index = (top + bottom) / 2;
             if (value == mZoomRatios[index]) {
               // exact match
               break;
             }
             if (value > mZoomRatios[index] && value < mZoomRatios[index + 1]) {
               // the specified zoom value lies in this interval
               break;
             }
             if (value > mZoomRatios[index]) {
               bottom = index + 1;
             } else {
               top = index - 1;
             }
           }
         }
         DOM_CAMERA_LOGI("Zoom = %fx --> index = %d\n", aValue, index);
       }
       return SetImpl(CAMERA_PARAM_ZOOM, index);
   }
   return SetImpl(aKey, aValue);
 }
 nsresult
 GonkCameraParameters::GetTranslated(uint32_t aKey, double& aValue)
 {
   double val;
   int index = 0;
   double focusDistance[3];
   const char* s;
   nsresult rv;
   switch (aKey) {
     case CAMERA_PARAM_ZOOM:
       rv = GetImpl(aKey, index);
       if (NS_SUCCEEDED(rv) && index >= 0) {
         val = mZoomRatios[index] / 100.0;
       } else {
         // return 1x when zooming is not supported
         val = 1.0;
         rv = NS_OK;
       }
       break;
     /**
      * The gonk camera parameters API only exposes one focus distance property
      * that contains "Near,Optimum,Far" distances, in metres, where 'Far' may
      * be 'Infinity'.
      */
     case CAMERA_PARAM_FOCUSDISTANCEFAR:
       ++index;
       // intentional fallthrough
     case CAMERA_PARAM_FOCUSDISTANCEOPTIMUM:
       ++index;
       // intentional fallthrough
     case CAMERA_PARAM_FOCUSDISTANCENEAR:
       rv = GetImpl(aKey, s);
       if (NS_SUCCEEDED(rv)) {
         if (sscanf(s, "%lf,%lf,%lf", &focusDistance[0], &focusDistance[1], &focusDistance[2]) == 3) {
           val = focusDistance[index];
         } else {
           val = 0.0;
         }
       }
       break;
     case CAMERA_PARAM_EXPOSURECOMPENSATION:
       rv = GetImpl(aKey, index);
       if (NS_SUCCEEDED(rv)) {
         if (!index) {
           // NaN indicates automatic exposure compensation
           val = NAN;
         } else {
           val = (index - 1) * mExposureCompensationStep + mExposureCompensationMin;
           DOM_CAMERA_LOGI("index = %d --> compensation = %f\n", index, val);
         }
       }
       break;
     default:
       rv = GetImpl(aKey, val);
       break;
   }
   if (NS_SUCCEEDED(rv)) {
     aValue = val;
   }
   return rv;
 }
 // Handle ints
 nsresult
 GonkCameraParameters::SetTranslated(uint32_t aKey, const int& aValue)
 {
   return SetImpl(aKey, aValue);
 }
 nsresult
 GonkCameraParameters::GetTranslated(uint32_t aKey, int& aValue)
 {
   return GetImpl(aKey, aValue);
 }
 // Handle uint32_ts -- Gonk only speaks int
 nsresult
 GonkCameraParameters::SetTranslated(uint32_t aKey, const uint32_t& aValue)
 {
   if (aValue > INT_MAX) {
     return NS_ERROR_INVALID_ARG;
   }
   int val = static_cast<int>(aValue);
   return SetImpl(aKey, val);
 }
 nsresult
 GonkCameraParameters::GetTranslated(uint32_t aKey, uint32_t& aValue)
 {
   int val;
   nsresult rv = GetImpl(aKey, val);
   if (NS_FAILED(rv)) {
     return rv;
   }
   if (val < 0) {
     return NS_ERROR_FAILURE;
   }
   aValue = val;
   return NS_OK;
 }
 // Handle bools
 nsresult
 GonkCameraParameters::SetTranslated(uint32_t aKey, const bool& aValue)
 {
   return SetImpl(aKey, aValue);
 }
 nsresult
 GonkCameraParameters::GetTranslated(uint32_t aKey, bool& aValue)
 {
   return GetImpl(aKey, aValue);
 }
 nsresult
 ParseItem(const char* aStart, const char* aEnd, ICameraControl::Size* aItem)
 {
   if (sscanf(aStart, "%ux%u", &aItem->width, &aItem->height) == 2) {
     return NS_OK;
   }
   DOM_CAMERA_LOGE("Size tuple has bad format: '%s'\n", __func__, __LINE__, aStart);
   return NS_ERROR_FAILURE;
 }
 nsresult
 ParseItem(const char* aStart, const char* aEnd, nsAString* aItem)
 {
   if (aEnd) {
     aItem->AssignASCII(aStart, aEnd - aStart);
   } else {
     aItem->AssignASCII(aStart);
   }
   return NS_OK;
 }
 nsresult
 ParseItem(const char* aStart, const char* aEnd, nsACString* aItem)
 {
   if (aEnd) {
     aItem->AssignASCII(aStart, aEnd - aStart);
   } else {
     aItem->AssignASCII(aStart);
   }
   return NS_OK;
 }
 nsresult
 ParseItem(const char* aStart, const char* aEnd, double* aItem)
 {
   if (sscanf(aStart, "%lf", aItem) == 1) {
     return NS_OK;
   }
   return NS_ERROR_FAILURE;
 }
 nsresult
 ParseItem(const char* aStart, const char* aEnd, int* aItem)
 {
   if (sscanf(aStart, "%d", aItem) == 1) {
     return NS_OK;
   }
   return NS_ERROR_FAILURE;
 }
 template<class T> nsresult
 GonkCameraParameters::GetListAsArray(uint32_t aKey, nsTArray<T>& aArray)
 {
   const char* p;
   nsresult rv = GetImpl(aKey, p);
   if (NS_FAILED(rv)) {
     return rv;
   }
   aArray.Clear();
   // If there is no value available, just return the empty array.
   if (!p) {
     DOM_CAMERA_LOGI("Camera parameter %d not available (value is null)\n", aKey);
     return NS_OK;
   }
   if (*p == '\0') {
     DOM_CAMERA_LOGI("Camera parameter %d not available (value is empty string)\n", aKey);
     return NS_OK;
   }
   const char* comma;
   while (p) {
     T* v = aArray.AppendElement();
     if (!v) {
       aArray.Clear();
       return NS_ERROR_OUT_OF_MEMORY;
     }
     comma = strchr(p, ',');
     if (comma != p) {
       rv = ParseItem(p, comma, v);
       if (NS_FAILED(rv)) {
         aArray.Clear();
         return rv;
       }
       p = comma;
     }
     if (p) {
       ++p;
     }
   }
   return NS_OK;
 }
 nsresult
 GonkCameraParameters::GetTranslated(uint32_t aKey, nsTArray<nsString>& aValues)
 {
   if (aKey == CAMERA_PARAM_SUPPORTED_ISOMODES) {
     aValues = mIsoModes;
     return NS_OK;
   }
   return GetListAsArray(aKey, aValues);
 }
 nsresult
 GonkCameraParameters::GetTranslated(uint32_t aKey, nsTArray<double>& aValues)
 {
   if (aKey == CAMERA_PARAM_SUPPORTED_ZOOMRATIOS) {
     aValues.Clear();
     for (uint32_t i = 0; i < mZoomRatios.Length(); ++i) {
       *aValues.AppendElement() = mZoomRatios[i] / 100.0;
     }
     return NS_OK;
   }
   return GetListAsArray(aKey, aValues);
 }
 nsresult
 GonkCameraParameters::GetTranslated(uint32_t aKey, nsTArray<ICameraControl::Size>& aSizes)
 {
   return GetListAsArray(aKey, aSizes);
 }

The Tor Browser / annotate

dom/camera/GonkCameraParameters.cpp@129ffea94266 (annotated)

dom/camera/GonkCameraParameters.cpp