Move most of TestNaClBrowserDelegate to another file.

chrome/browser/nacl_host/nacl_file_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 "chrome/browser/nacl_host/nacl_file_host.h"
 
 #include "base/basictypes.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/run_loop.h"
 #include "base/test/scoped_path_override.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "chrome/browser/nacl_host/nacl_browser.h"
-#include "components/nacl/common/nacl_browser_delegate.h"
 #include "components/nacl/common/pnacl_types.h"
+#include "components/nacl/common/test_nacl_browser_delegate.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using nacl_file_host::PnaclCanOpenFile;
 using nacl_file_host::EnsurePnaclInstalled;
 
-class TestNaClBrowserDelegate : public NaClBrowserDelegate {
+class FileHostTestNaclBrowserDelegate : public TestNaClBrowserDelegate {

[Mark Seaborn, 2013/10/31 02:36:38]

Can you fix the spelling to be "NaCl" not "Nacl" here, since you're changing the
name?

[jvoung (off chromium), 2013/10/31 16:59:55]

Done.

  public:
-
-  TestNaClBrowserDelegate() : should_pnacl_install_succeed_(false) { }
-
-  virtual void ShowNaClInfobar(int render_process_id,
-                               int render_view_id,
-                               int error_id) OVERRIDE {
-  }
-
-  virtual bool DialogsAreSuppressed() OVERRIDE {
-    return false;
-  }
-
-  virtual bool GetCacheDirectory(base::FilePath* cache_dir) OVERRIDE {
-    return false;
-  }
-
-  virtual bool GetPluginDirectory(base::FilePath* plugin_dir) OVERRIDE {
-    return false;
-  }
+  FileHostTestNaclBrowserDelegate() : should_pnacl_install_succeed_(false) {}
 
   virtual bool GetPnaclDirectory(base::FilePath* pnacl_dir) OVERRIDE {
     *pnacl_dir = pnacl_path_;
     return true;
   }
 
-  virtual bool GetUserDirectory(base::FilePath* user_dir) OVERRIDE {
-    return false;
-  }
-
-  virtual std::string GetVersionString() const OVERRIDE {
-    return std::string();
-  }
-
-  virtual ppapi::host::HostFactory* CreatePpapiHostFactory(
-      content::BrowserPpapiHost* ppapi_host) OVERRIDE {
-    return NULL;
-  }
-
-  virtual bool MapUrlToLocalFilePath(const GURL& file_url,
-                                     bool use_blocking_api,
-                                     base::FilePath* file_path) OVERRIDE {
-    return false;
-  }
-
-  virtual void SetDebugPatterns(std::string debug_patterns) OVERRIDE {
-  }
-
-  virtual bool URLMatchesDebugPatterns(const GURL& manifest_url) OVERRIDE {
-    return false;
-  }
-
-  virtual void TryInstallPnacl(
-      const base::Callback<void(bool)>& installed) OVERRIDE {
+  virtual void TryInstallPnacl(const base::Callback<void(bool)>& installed)
+      OVERRIDE {
     installed.Run(should_pnacl_install_succeed_);
   }
 
   void SetPnaclDirectory(const base::FilePath& pnacl_dir) {
     pnacl_path_ = pnacl_dir;
   }
 
   // Indicate if we should mock the PNaCl install as succeeding
   // or failing for the next test.
   void SetShouldPnaclInstallSucceed(bool succeed) {
     should_pnacl_install_succeed_ = succeed;
   }
 
  private:
   base::FilePath pnacl_path_;
   bool should_pnacl_install_succeed_;
 };
 
 class NaClFileHostTest : public testing::Test {
  protected:
   NaClFileHostTest();
   virtual ~NaClFileHostTest();
 
   virtual void SetUp() OVERRIDE {
-    nacl_browser_delegate_ = new TestNaClBrowserDelegate;
+    nacl_browser_delegate_ = new FileHostTestNaclBrowserDelegate;
     NaClBrowser::SetDelegate(nacl_browser_delegate_);
   }
 
   virtual void TearDown() OVERRIDE {
     NaClBrowser::SetDelegate(NULL);  // This deletes nacl_browser_delegate_
   }
 
-  TestNaClBrowserDelegate* nacl_browser_delegate() {
+  FileHostTestNaclBrowserDelegate* nacl_browser_delegate() {
     return nacl_browser_delegate_;
   }
 
   bool install_success() { return install_success_; }
   size_t install_call_count() {
     return std::count(events_.begin(), events_.end(), INSTALL_DONE);
   }
   size_t progress_call_count() {
     return std::count(events_.begin(), events_.end(), INSTALL_PROGRESS);
   }
@@ skipping 20 matching lines @@
     // TODO(jvoung): be able to check that current_progress
     // goes up monotonically and hits total_progress at the end,
     // when we actually get real progress events.
   }
 
  private:
   enum EventType {
     INSTALL_DONE,
     INSTALL_PROGRESS
   };
-  TestNaClBrowserDelegate* nacl_browser_delegate_;
+  FileHostTestNaclBrowserDelegate* nacl_browser_delegate_;
   bool install_success_;
   std::vector<EventType> events_;
   content::TestBrowserThreadBundle thread_bundle_;
   DISALLOW_COPY_AND_ASSIGN(NaClFileHostTest);
 };
 
 NaClFileHostTest::NaClFileHostTest()
     : nacl_browser_delegate_(NULL),
       install_success_(false),
       thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP) {
@@ skipping 112 matching lines @@
       base::Bind(&NaClFileHostTest::CallbackInstall, base::Unretained(this)),
       base::Bind(&NaClFileHostTest::CallbackProgress, base::Unretained(this)));
   content::BrowserThread::GetBlockingPool()->FlushForTesting();
   base::RunLoop().RunUntilIdle();
 
   EXPECT_FALSE(install_success());
   EXPECT_EQ(1u, install_call_count());
   EXPECT_GE(progress_call_count(), 1u);
   EXPECT_TRUE(events_in_correct_order());
 }