Make calls to AtomicString(const String&) explicit in dom/

Source/core/dom/Attr.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Peter Kelly (pmk@post.com)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2009, 2010, 2012 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
@@ skipping 123 matching lines @@
 {
     if (m_element)
         m_element->willModifyAttribute(qualifiedName(), this->value(), value);
 
     setValue(value);
 
     if (m_element)
         m_element->didModifyAttribute(qualifiedName(), value);
 }
 
 void Attr::setNodeValue(const String& v)

[eseidel, 2013/12/15 16:51:26]

Does this eventually change to AtomicString too?

[Inactive, 2013/12/16 14:26:27]

The reason I did not update setNodeValue() to take an AtomicString is that this
is a virtual method and not all class implementing it expect an AtomicString.
For e.g. CharacterData::setNodeValue() expects a String.

[eseidel, 2013/12/30 17:19:27]

But why are values atomic in the first place?  What are typical node values?

[Inactive, 2013/12/30 19:53:34]

Node values are not atomic, they are Strings and I did not change that.
setNodeValue() virtual method is implemented by both Attr and CharacterData.
Using AtomicString for the CharacterData text does not seem to make much sense.
However, Attr uses AtomicString internally to store its value (The value of an
Element's attribute). 

I assume there is a lot of duplication among Element attributes values on a Web
page. Therefore, using AtomicString for them seems to make sense to save memory.
I think calling AtomicString() explicitly here is the right thing to do as I
don't think we want to move CharacterData's data to AtomicString type.

 {
-    setValue(v, IGNORE_EXCEPTION);
+    setValue(AtomicString(v), IGNORE_EXCEPTION);
 }
 
 PassRefPtr<Node> Attr::cloneNode(bool /*deep*/)
 {
     RefPtr<Attr> clone = adoptRef(new Attr(document(), qualifiedName(), value()));
     cloneChildNodes(clone.get());
     return clone.release();
 }
 
 // DOM Section 1.1.1
@@ skipping 56 matching lines @@
 }
 
 void Attr::attachToElement(Element* element)
 {
     ASSERT(!m_element);
     m_element = element;
     m_standaloneValue = nullAtom;
 }
 
 }