Revert 185189.

chrome/browser/extensions/api/messaging/native_message_process_host_unittest.cc

 // Copyright (c) 2012 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 "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 15 matching lines @@
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/features/feature.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/test/test_browser_thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using content::BrowserThread;
 
 namespace {
 
-const char kTestHostId[] = "knldjmfmopnpolahpmmgbagdohdnhkik";
 const char kTestMessage[] = "{\"text\": \"Hello.\"}";
 
 base::FilePath GetTestDir() {
   base::FilePath test_dir;
   PathService::Get(chrome::DIR_TEST_DATA, &test_dir);
   test_dir = test_dir.AppendASCII("native_messaging");
   return test_dir;
 }
 
 }  // namespace
 
 namespace extensions {
 
 class FakeLauncher : public NativeProcessLauncher {
  public:
   FakeLauncher(base::FilePath read_file, base::FilePath write_file) {
     read_file_ = base::CreatePlatformFile(
         read_file,
         base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_READ |
             base::PLATFORM_FILE_ASYNC,
         NULL, NULL);
     write_file_ = base::CreatePlatformFile(
         write_file,
         base::PLATFORM_FILE_CREATE | base::PLATFORM_FILE_WRITE |
             base::PLATFORM_FILE_ASYNC,
         NULL, NULL);
   }
 
-  virtual void Launch(const GURL& origin,
-                      const std::string& native_host_name,
+  virtual void Launch(const std::string& native_host_name,
                       LaunchedCallback callback) const OVERRIDE {
     callback.Run(base::GetCurrentProcessHandle(), read_file_, write_file_);
   }
 
  private:
   base::PlatformFile read_file_;
   base::PlatformFile write_file_;
 };
 
 class NativeMessagingTest : public ::testing::Test,
@@ skipping 69 matching lines @@
 };
 
 // Read a single message from a local file.
 TEST_F(NativeMessagingTest, SingleSendMessageRead) {
   base::FilePath temp_output_file = temp_dir_.path().AppendASCII("output");
   base::FilePath temp_input_file = CreateTempFileWithMessage(kTestMessage);
 
   scoped_ptr<NativeProcessLauncher> launcher(
       new FakeLauncher(temp_input_file, temp_output_file));
   native_message_process_host_ = NativeMessageProcessHost::CreateWithLauncher(
-      AsWeakPtr(), kTestHostId, "empty_app.py", 0, launcher.Pass());
+      AsWeakPtr(), "empty_app.py", 0, launcher.Pass());
   ASSERT_TRUE(native_message_process_host_.get());
   message_loop_.RunUntilIdle();
 
   native_message_process_host_->ReadNowForTesting();
   read_message_run_loop_.Run();
   EXPECT_EQ(kTestMessage, last_posted_message_);
 }
 
 // Tests sending a single message. The message should get written to
 // |temp_file| and should match the contents of single_message_request.msg.
 TEST_F(NativeMessagingTest, SingleSendMessageWrite) {
   base::FilePath temp_output_file = temp_dir_.path().AppendASCII("output");
   base::FilePath temp_input_file = CreateTempFileWithMessage(std::string());
 
   scoped_ptr<NativeProcessLauncher> launcher(
       new FakeLauncher(temp_input_file, temp_output_file));
   native_message_process_host_ = NativeMessageProcessHost::CreateWithLauncher(
-      AsWeakPtr(), kTestHostId, "empty_app.py", 0, launcher.Pass());
+      AsWeakPtr(), "empty_app.py", 0, launcher.Pass());
   ASSERT_TRUE(native_message_process_host_.get());
   message_loop_.RunUntilIdle();
 
   native_message_process_host_->Send(kTestMessage);
   message_loop_.RunUntilIdle();
 
   std::string output;
   base::TimeTicks start_time = base::TimeTicks::Now();
   while (base::TimeTicks::Now() - start_time < TestTimeouts::action_timeout()) {
     ASSERT_TRUE(file_util::ReadFileToString(temp_output_file, &output));
     if (!output.empty())
       break;
     base::PlatformThread::YieldCurrentThread();
   }
 
   EXPECT_EQ(FormatMessage(kTestMessage), output);
 }
 
 // Disabled, see http://crbug.com/159754.
 // Test send message with a real client. The client just echo's back the text
 // it recieved.
 TEST_F(NativeMessagingTest, DISABLED_EchoConnect) {
   native_message_process_host_ = NativeMessageProcessHost::Create(
-      AsWeakPtr(), kTestHostId, "empty_app.py", 0);
+      AsWeakPtr(), "empty_app.py", 0);
   ASSERT_TRUE(native_message_process_host_.get());
   message_loop_.RunUntilIdle();
 
   native_message_process_host_->Send("{\"text\": \"Hello.\"}");
   read_message_run_loop_.Run();
   EXPECT_EQ("{\"id\": 1, \"echo\": {\"text\": \"Hello.\"}}",
             last_posted_message_);
 
   native_message_process_host_->Send("{\"foo\": \"bar\"}");
   read_message_run_loop_.Run();
   EXPECT_EQ("{\"id\": 2, \"echo\": {\"foo\": \"bar\"}}", last_posted_message_);
 }
 
 }  // namespace extensions