Add Skia to the GN build.

tools/gn/operators.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 "tools/gn/operators.h"
 
 #include "base/strings/string_number_conversions.h"
 #include "tools/gn/err.h"
 #include "tools/gn/parse_tree.h"
 #include "tools/gn/scope.h"
@@ skipping 398 matching lines @@
 }
 
 // Binary ----------------------------------------------------------------------
 
 Value ExecuteOr(Scope* scope,
                 const BinaryOpNode* op_node,
                 const Value& left,
                 const Value& right,
                 Err* err) {
   if (left.type() != Value::BOOLEAN) {
-    *err = Err(left, "Left side of || operator is not a boolean.");
-    err->AppendRange(op_node->GetRange());
+    *err = Err(op_node->left(), "Left side of || operator is not a boolean.",
+        "Type is \"" + std::string(Value::DescribeType(left.type())) +
+        "\" instead.");
+    return Value();
   } else if (right.type() != Value::BOOLEAN) {
-    *err = Err(right, "Right side of || operator is not a boolean.");
-    err->AppendRange(op_node->GetRange());
+    *err = Err(op_node->right(), "Right side of || operator is not a boolean.",
+        "Type is \"" + std::string(Value::DescribeType(right.type())) +
+        "\" instead.");
+    return Value();
   }
   return Value(op_node, left.boolean_value() || right.boolean_value());
 }
 
 Value ExecuteAnd(Scope* scope,
                  const BinaryOpNode* op_node,
                  const Value& left,
                  const Value& right,
                  Err* err) {
   if (left.type() != Value::BOOLEAN) {
-    *err = Err(left, "Left side of && operator is not a boolean.");
-    err->AppendRange(op_node->GetRange());
+    *err = Err(op_node->left(), "Left side of && operator is not a boolean.",
+        "Type is \"" + std::string(Value::DescribeType(left.type())) +
+        "\" instead.");
+    return Value();
   } else if (right.type() != Value::BOOLEAN) {
-    *err = Err(right, "Right side of && operator is not a boolean.");
-    err->AppendRange(op_node->GetRange());
+    *err = Err(op_node->right(), "Right side of && operator is not a boolean.",
+        "Type is \"" + std::string(Value::DescribeType(right.type())) +
+        "\" instead.");
+    return Value();
   }
   return Value(op_node, left.boolean_value() && right.boolean_value());
 }
 
 }  // namespace
 
 // ----------------------------------------------------------------------------
 
 bool IsUnaryOperator(const Token& token) {
   return token.type() == Token::BANG;
@@ skipping 31 matching lines @@
   return token.type() == Token::RIGHT_BRACE;
 }
 
 Value ExecuteUnaryOperator(Scope* scope,
                            const UnaryOpNode* op_node,
                            const Value& expr,
                            Err* err) {
   DCHECK(op_node->op().type() == Token::BANG);
 
   if (expr.type() != Value::BOOLEAN) {
-    *err = Err(expr, "Operand of ! operator is not a boolean.");
-    err->AppendRange(op_node->GetRange());
+    *err = Err(op_node, "Operand of ! operator is not a boolean.",
+        "Type is \"" + std::string(Value::DescribeType(expr.type())) +
+        "\" instead.");
     return Value();
   }
   // TODO(scottmg): Why no unary minus?
   return Value(op_node, !expr.boolean_value());
 }
 
 Value ExecuteBinaryOperator(Scope* scope,
                             const BinaryOpNode* op_node,
                             const ParseNode* left,
                             const ParseNode* right,
@@ skipping 77 matching lines @@
     return ExecuteLess(scope, op_node, left_value, right_value, err);
 
   // ||, &&.
   if (op.type() == Token::BOOLEAN_OR)
     return ExecuteOr(scope, op_node, left_value, right_value, err);
   if (op.type() == Token::BOOLEAN_AND)
     return ExecuteAnd(scope, op_node, left_value, right_value, err);
 
   return Value();
 }