base: Add Is* functions to Value class.

chrome/test/webdriver/webdriver_session.cc

 // Copyright (c) 2011 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/webdriver/webdriver_session.h"
 
 #include <sstream>
 #include <vector>
 
 #include "base/command_line.h"
@@ skipping 1119 matching lines @@
     const std::string& script, ListValue* args) {
   class SwitchFrameValueParser : public ValueParser {
    public:
     SwitchFrameValueParser(
         bool* found_frame, ElementId* frame, std::string* xpath)
         : found_frame_(found_frame), frame_(frame), xpath_(xpath) { }
 
     virtual ~SwitchFrameValueParser() { }
 
     virtual bool Parse(base::Value* value) const OVERRIDE {
-      if (value->IsType(Value::TYPE_NULL)) {
+      if (value->IsNull()) {
         *found_frame_ = false;
         return true;
       }
       ListValue* list;
       if (!value->GetAsList(&list))
         return false;
       *found_frame_ = true;
       return SetFromListValue(list, frame_, xpath_);
     }
 
@@ skipping 60 matching lines @@
   CHECK(root_element.is_valid());
 
   class FindElementsParser : public ValueParser {
    public:
     explicit FindElementsParser(std::vector<ElementId>* elements)
         : elements_(elements) { }
 
     virtual ~FindElementsParser() { }
 
     virtual bool Parse(base::Value* value) const OVERRIDE {
-      if (!value->IsType(Value::TYPE_LIST))
+      if (!value->IsList())
         return false;
       ListValue* list = static_cast<ListValue*>(value);
       for (size_t i = 0; i < list->GetSize(); ++i) {
         ElementId element;
         Value* element_value = NULL;
         if (!list->Get(i, &element_value))
           return false;
         if (!SetFromValue(element_value, &element))
           return false;
         elements_->push_back(element);
       }
       return true;
     }
    private:
     std::vector<ElementId>* elements_;
   };
 
   class FindElementParser : public ValueParser {
    public:
     explicit FindElementParser(std::vector<ElementId>* elements)
         : elements_(elements) { }
 
     virtual ~FindElementParser() { }
 
     virtual bool Parse(base::Value* value) const OVERRIDE {
-      if (value->IsType(Value::TYPE_NULL))
+      if (value->IsNull())
         return true;
       ElementId element;
       bool set = SetFromValue(value, &element);
       if (set)
         elements_->push_back(element);
       return set;
     }
    private:
     std::vector<ElementId>* elements_;
   };
@@ skipping 27 matching lines @@
     const ElementId& element,
     const Point& location) {
   class IsElementClickableParser : public ValueParser {
    public:
     IsElementClickableParser(bool* clickable, std::string* message)
         : clickable_(clickable), message_(message) { }
 
     virtual ~IsElementClickableParser() { }
 
     virtual bool Parse(base::Value* value) const OVERRIDE {
-      if (!value->IsType(Value::TYPE_DICTIONARY))
+      if (!value->IsDictionary())
         return false;
       DictionaryValue* dict = static_cast<DictionaryValue*>(value);
       dict->GetString("message", message_);
       return dict->GetBoolean("clickable", clickable_);
     }
 
    private:
     bool* clickable_;
     std::string* message_;
   };
@@ skipping 80 matching lines @@
 Error* Session::GetAppCacheStatus(int* status) {
   return ExecuteScriptAndParse(
       current_target_,
       atoms::GET_APPCACHE_STATUS,
       "getAppcacheStatus",
       new ListValue(),
       CreateDirectValueParser(status));
 }
 
 }  // namespace webdriver