Avoids the use of "namespace using-directives" in a few places....

webkit/glue/glue_serialize_unittest.cc

 // Copyright (c) 2006-2008 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 <string>
 
 #include "base/pickle.h"
 #include "base/string_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/api/public/WebHTTPBody.h"
 #include "webkit/api/public/WebPoint.h"
 #include "webkit/api/public/WebVector.h"
 #include "webkit/glue/glue_serialize.h"
 
-using namespace std;
-using namespace webkit_glue;
-
 using WebKit::WebData;
 using WebKit::WebHistoryItem;
 using WebKit::WebHTTPBody;
 using WebKit::WebPoint;
 using WebKit::WebString;
 using WebKit::WebUChar;
 using WebKit::WebVector;
 
 namespace {
 class GlueSerializeTest : public testing::Test {
@@ skipping 78 matching lines @@
     const WebHTTPBody& a_body = a.httpBody();
     const WebHTTPBody& b_body = b.httpBody();
     EXPECT_EQ(!a_body.isNull(), !b_body.isNull());
     if (!a_body.isNull() && !b_body.isNull()) {
       EXPECT_EQ(a_body.elementCount(), b_body.elementCount());
       WebHTTPBody::Element a_elem, b_elem;
       for (size_t i = 0; a_body.elementAt(i, a_elem) &&
                          b_body.elementAt(i, b_elem); ++i) {
         EXPECT_EQ(a_elem.type, b_elem.type);
         if (a_elem.type == WebHTTPBody::Element::TypeData) {
-          EXPECT_EQ(string(a_elem.data.data(), a_elem.data.size()),
-                    string(b_elem.data.data(), b_elem.data.size()));
+          EXPECT_EQ(std::string(a_elem.data.data(), a_elem.data.size()),
+                    std::string(b_elem.data.data(), b_elem.data.size()));
         } else {
           EXPECT_EQ(string16(a_elem.filePath), string16(b_elem.filePath));
         }
       }
     }
     EXPECT_EQ(string16(a.httpContentType()), string16(b.httpContentType()));
 
     // Children
     const WebVector<WebHistoryItem>& a_children = a.children();
     const WebVector<WebHistoryItem>& b_children = b.children();
     EXPECT_EQ(a_children.size(), b_children.size());
     for (size_t i = 0, c = a_children.size(); i < c; ++i)
       HistoryItemExpectEqual(a_children[i], b_children[i]);
   }
 };
 
 // Test old versions of serialized data to ensure that newer versions of code
 // can still read history items written by previous versions.
 TEST_F(GlueSerializeTest, BackwardsCompatibleTest) {
   const WebHistoryItem& item = MakeHistoryItem(false, false);
 
   // Make sure version 3 (current version) can read versions 1 and 2.
   for (int i = 1; i <= 2; i++) {
-    string serialized_item;
-    HistoryItemToVersionedString(item, i, &serialized_item);
+    std::string serialized_item;
+    webkit_glue::HistoryItemToVersionedString(item, i, &serialized_item);
     const WebHistoryItem& deserialized_item =
-        HistoryItemFromString(serialized_item);
+        webkit_glue::HistoryItemFromString(serialized_item);
     ASSERT_FALSE(item.isNull());
     ASSERT_FALSE(deserialized_item.isNull());
     HistoryItemExpectEqual(item, deserialized_item);
   }
 }
 
 // Makes sure that a HistoryItem remains intact after being serialized and
 // deserialized.
 TEST_F(GlueSerializeTest, HistoryItemSerializeTest) {
   const WebHistoryItem& item = MakeHistoryItem(true, true);
-  const string& serialized_item = HistoryItemToString(item);
+  const std::string& serialized_item = webkit_glue::HistoryItemToString(item);
   const WebHistoryItem& deserialized_item =
-      HistoryItemFromString(serialized_item);
+      webkit_glue::HistoryItemFromString(serialized_item);
 
   ASSERT_FALSE(item.isNull());
   ASSERT_FALSE(deserialized_item.isNull());
   HistoryItemExpectEqual(item, deserialized_item);
 }
 
 // Checks that broken messages don't take out our process.
 TEST_F(GlueSerializeTest, BadMessagesTest) {
   {
     Pickle p;
     // Version 1
     p.WriteInt(1);
     // Empty strings.
     for (int i = 0; i < 6; ++i)
       p.WriteInt(-1);
     // Bad real number.
     p.WriteInt(-1);
     std::string s(static_cast<const char*>(p.data()), p.size());
-    HistoryItemFromString(s);
+    webkit_glue::HistoryItemFromString(s);
   }
   {
     double d = 0;
     Pickle p;
     // Version 1
     p.WriteInt(1);
     // Empty strings.
     for (int i = 0; i < 6; ++i)
       p.WriteInt(-1);
     // More misc fields.
     p.WriteData(reinterpret_cast<const char*>(&d), sizeof(d));
     p.WriteInt(1);
     p.WriteInt(1);
     p.WriteInt(0);
     p.WriteInt(0);
     p.WriteInt(-1);
     p.WriteInt(0);
     // WebForm
     p.WriteInt(1);
     p.WriteInt(WebHTTPBody::Element::TypeData);
     std::string s(static_cast<const char*>(p.data()), p.size());
-    HistoryItemFromString(s);
+    webkit_glue::HistoryItemFromString(s);
   }
 }
 
-
-} // namespace
+}  // namespace