base: Remove using declaration of BinaryValue as it's no longer necessary.

ipc/ipc_message_utils.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 "ipc/ipc_message_utils.h"
 
 #include "base/file_path.h"
 #include "base/json/json_writer.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/nullable_string16.h"
@@ skipping 44 matching lines @@
       WriteParam(m, val);
       break;
     }
     case Value::TYPE_STRING: {
       std::string val;
       value->GetAsString(&val);
       WriteParam(m, val);
       break;
     }
     case Value::TYPE_BINARY: {
-      const BinaryValue* binary = static_cast<const BinaryValue*>(value);
+      const base::BinaryValue* binary =
+          static_cast<const base::BinaryValue*>(value);
       m->WriteData(binary->GetBuffer(), static_cast<int>(binary->GetSize()));
       break;
     }
     case Value::TYPE_DICTIONARY: {
       const DictionaryValue* dict = static_cast<const DictionaryValue*>(value);
 
       WriteParam(m, static_cast<int>(dict->size()));
 
       for (DictionaryValue::key_iterator it = dict->begin_keys();
            it != dict->end_keys(); ++it) {
@@ skipping 102 matching lines @@
       if (!ReadParam(m, iter, &val))
         return false;
       *value = Value::CreateStringValue(val);
       break;
     }
     case Value::TYPE_BINARY: {
       const char* data;
       int length;
       if (!m->ReadData(iter, &data, &length))
         return false;
-      *value = BinaryValue::CreateWithCopiedBuffer(data, length);
+      *value = base::BinaryValue::CreateWithCopiedBuffer(data, length);
       break;
     }
     case Value::TYPE_DICTIONARY: {
       scoped_ptr<DictionaryValue> val(new DictionaryValue());
       if (!ReadDictionaryValue(m, iter, val.get(), recursion))
         return false;
       *value = val.release();
       break;
     }
     case Value::TYPE_LIST: {
@@ skipping 269 matching lines @@
       ReadParam(m, iter, &r->flags) &&
       ReadParam(m, iter, &r->sent) &&
       ReadParam(m, iter, &r->receive) &&
       ReadParam(m, iter, &r->dispatch) &&
       ReadParam(m, iter, &r->params);
   r->type = static_cast<uint16>(type);
   return result;
 }
 
 }  // namespace IPC