[chromedriver] Fix bug in command for GetElementValueOfCSSProperty.

chrome/test/chromedriver/element_util.cc

 // Copyright (c) 2013 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/test/chromedriver/element_util.h"
 
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/threading/platform_thread.h"
@@ skipping 96 matching lines @@
   args.Append(CreateValueFrom(location));
   scoped_ptr<base::Value> result;
   Status status = CallAtomsJs(
       frame, web_view, webdriver::atoms::IS_ELEMENT_CLICKABLE,
       args, &result);
   if (status.IsError())
     return status;
   base::DictionaryValue* dict;
   bool is_clickable;
   if (!result->GetAsDictionary(&dict) ||
-      !dict->GetBoolean("clickable", &is_clickable))
-    return Status(kUnknownError, "fail to parse value of IS_ELEMENT_CLICKABLE");
+      !dict->GetBoolean("clickable", &is_clickable)) {
+    return Status(kUnknownError,
+                  "failed to parse value of IS_ELEMENT_CLICKABLE");
+  }
 
   if (!is_clickable) {
     std::string message;
     if (!dict->GetString("message", &message))
       message = "element is not clickable";
     return Status(kUnknownError, message);
   }
   return Status(kOk);
 }
 
 Status ScrollElementRegionIntoViewHelper(
     const std::string& frame,
     WebView* web_view,
     const std::string& element_id,
     const WebRect& region,
     bool center,
     bool verify_clickable,
     WebPoint* location) {
   WebPoint tmp_location = *location;
   base::ListValue args;
   args.Append(CreateElement(element_id));
   args.AppendBoolean(center);
   args.Append(CreateValueFrom(region));
   scoped_ptr<base::Value> result;
   Status status = web_view->CallFunction(
       frame, webdriver::atoms::asString(webdriver::atoms::GET_LOCATION_IN_VIEW),
       args, &result);
   if (status.IsError())
     return status;
-  if (!ParseFromValue(result.get(), &tmp_location))
-    return Status(kUnknownError, "fail to parse value of GET_LOCATION_IN_VIEW");
+  if (!ParseFromValue(result.get(), &tmp_location)) {
+    return Status(kUnknownError,
+                  "failed to parse value of GET_LOCATION_IN_VIEW");
+  }
   if (verify_clickable) {
     WebPoint middle = tmp_location;
     middle.Offset(region.Width() / 2, region.Height() / 2);
     status = VerifyElementClickable(frame, web_view, element_id, middle);
     if (status.IsError())
       return status;
   }
   *location = tmp_location;
   return Status(kOk);
 }
 
 Status GetElementEffectiveStyle(
     const std::string& frame,
     WebView* web_view,
     const std::string& element_id,
     const std::string& property,
     std::string* value) {
   base::ListValue args;
   args.Append(CreateElement(element_id));
   args.AppendString(property);
   scoped_ptr<base::Value> result;
   Status status = web_view->CallFunction(
       frame, webdriver::atoms::asString(webdriver::atoms::GET_EFFECTIVE_STYLE),
       args, &result);
   if (status.IsError())
     return status;
-  if (!result->GetAsString(value))
-    return Status(kUnknownError, "fail to parse value of GET_EFFECTIVE_STYLE");
+  if (!result->GetAsString(value)) {
+    return Status(kUnknownError,
+                  "failed to parse value of GET_EFFECTIVE_STYLE");
+  }
   return Status(kOk);
 }
 
 Status GetElementBorder(
     const std::string& frame,
     WebView* web_view,
     const std::string& element_id,
     int* border_left,
     int* border_top) {
   std::string border_left_str;
   Status status = GetElementEffectiveStyle(
       frame, web_view, element_id, "border-left-width", &border_left_str);
   if (status.IsError())
     return status;
   std::string border_top_str;
   status = GetElementEffectiveStyle(
       frame, web_view, element_id, "border-top-width", &border_top_str);
   if (status.IsError())
     return status;
   int border_left_tmp = -1;
   int border_top_tmp = -1;
   base::StringToInt(border_left_str, &border_left_tmp);
   base::StringToInt(border_top_str, &border_top_tmp);
   if (border_left_tmp == -1 || border_top_tmp == -1)
-    return Status(kUnknownError, "fail to get border width of element");
+    return Status(kUnknownError, "failed to get border width of element");
   *border_left = border_left_tmp;
   *border_top = border_top_tmp;
   return Status(kOk);
 }
 
 }  // namespace
 
 base::DictionaryValue* CreateElement(const std::string& element_id) {
   base::DictionaryValue* element = new base::DictionaryValue();
   element->SetString(kElementKey, element_id);
@@ skipping 120 matching lines @@
 
   status = ScrollElementRegionIntoView(
       session, web_view, element_id, rect,
       true /* center */, true /* verify_clickable */, location);
   if (status.IsError())
     return status;
   location->Offset(rect.Width() / 2, rect.Height() / 2);
   return Status(kOk);
 }
 
+Status GetElementEffectiveStyle(
+    Session* session,
+    WebView* web_view,
+    const std::string& element_id,
+    const std::string& property_name,
+    std::string* property_value) {
+  return GetElementEffectiveStyle(session->GetCurrentFrameId(), web_view,
+                                  element_id, property_name, property_value);
+}
+
 Status GetElementRegion(
     Session* session,
     WebView* web_view,
     const std::string& element_id,
     WebRect* rect) {
   base::ListValue args;
   args.Append(CreateElement(element_id));
   scoped_ptr<base::Value> result;
   Status status = web_view->CallFunction(
       session->GetCurrentFrameId(), kGetElementRegionScript, args, &result);
   if (status.IsError())
     return status;
   if (!ParseFromValue(result.get(), rect)) {
     return Status(kUnknownError,
-        "fail to parse value of getElementRegion");
+                  "failed to parse value of getElementRegion");
   }
   return Status(kOk);
 }
 
 Status GetElementTagName(
     Session* session,
     WebView* web_view,
     const std::string& element_id,
     std::string* name) {
   base::ListValue args;
   args.Append(CreateElement(element_id));
   scoped_ptr<base::Value> result;
   Status status = web_view->CallFunction(
       session->GetCurrentFrameId(),
       "function(elem) { return elem.tagName.toLowerCase(); }",
       args, &result);
   if (status.IsError())
     return status;
   if (!result->GetAsString(name))
-    return Status(kUnknownError, "fail to get element tag name");
+    return Status(kUnknownError, "failed to get element tag name");
   return Status(kOk);
 }
 
 Status GetElementSize(
     Session* session,
     WebView* web_view,
     const std::string& element_id,
     WebSize* size) {
   base::ListValue args;
   args.Append(CreateElement(element_id));
   scoped_ptr<base::Value> result;
   Status status = CallAtomsJs(
       session->GetCurrentFrameId(), web_view, webdriver::atoms::GET_SIZE,
       args, &result);
   if (status.IsError())
     return status;
   if (!ParseFromValue(result.get(), size))
-    return Status(kUnknownError, "fail to parse value of GET_SIZE");
+    return Status(kUnknownError, "failed to parse value of GET_SIZE");
   return Status(kOk);
 }
 
 Status IsElementDisplayed(
     Session* session,
     WebView* web_view,
     const std::string& element_id,
     bool ignore_opacity,
     bool* is_displayed) {
   base::ListValue args;
@@ skipping 53 matching lines @@
     bool* is_togglable) {
   base::ListValue args;
   args.Append(CreateElement(element_id));
   scoped_ptr<base::Value> result;
   Status status = web_view->CallFunction(
       session->GetCurrentFrameId(), kIsOptionElementToggleableScript,
       args, &result);
   if (status.IsError())
     return status;
   if (!result->GetAsBoolean(is_togglable))
-    return Status(kUnknownError, "fail check if option togglable or not");
+    return Status(kUnknownError, "failed check if option togglable or not");
   return Status(kOk);
 }
 
 Status SetOptionElementSelected(
     Session* session,
     WebView* web_view,
     const std::string& element_id,
     bool selected) {
   // TODO(171034): need to fix throwing error if an alert is triggered.
   base::ListValue args;
@@ skipping 60 matching lines @@
     scoped_ptr<base::Value> result;
     status = web_view->CallFunction(
         rit->parent_frame_id, kFindSubFrameScript, args, &result);
     if (status.IsError())
       return status;
     const base::DictionaryValue* element_dict;
     if (!result->GetAsDictionary(&element_dict))
       return Status(kUnknownError, "no element reference returned by script");
     std::string frame_element_id;
     if (!element_dict->GetString(kElementKey, &frame_element_id))
-      return Status(kUnknownError, "fail to locate a sub frame");
+      return Status(kUnknownError, "failed to locate a sub frame");
 
     // Modify |region_offset| by the frame's border.
     int border_left = -1;
     int border_top = -1;
     status = GetElementBorder(
         rit->parent_frame_id, web_view, frame_element_id,
         &border_left, &border_top);
     if (status.IsError())
       return status;
     region_offset.Offset(border_left, border_top);
 
     status = ScrollElementRegionIntoViewHelper(
         rit->parent_frame_id, web_view, frame_element_id,
         WebRect(region_offset, region_size),
         center, verify_clickable, &region_offset);
     if (status.IsError())
       return status;
   }
   *location = region_offset;
   return Status(kOk);
 }