diff --git a/delta_diff_generator.cc b/delta_diff_generator.cc
index f5f8bec..c1ed86f 100644
--- a/delta_diff_generator.cc
+++ b/delta_diff_generator.cc
@@ -104,17 +104,17 @@
 
   // TODO(dgarrett): chromium-os:15274 Wire up this file all of the way to
   // command line.
-  static const char* black_files[] = {
-    "/opt/google/chrome/pepper/libnetflixidd.so"
-  };
+  //
+  // To hardcode for now, use the following instead of true.
+  //   (path != "/opt/google/chrome/pepper/libnetflixidd.so");
+  bool bsdiff_allowed = true;
 
-  std::set<string> bsdiff_blacklist = std::set<string>(black_files,
-                                                       black_files +
-                                                       arraysize(black_files));
+  if (!bsdiff_allowed)
+    LOG(INFO) << "bsdiff blacklisting: " << path;
 
   TEST_AND_RETURN_FALSE(DeltaDiffGenerator::ReadFileToDiff(old_path,
                                                            new_root + path,
-                                                           bsdiff_blacklist,
+                                                           bsdiff_allowed,
                                                            &data,
                                                            &operation,
                                                            true));
@@ -409,12 +409,13 @@
   DeltaArchiveManifest_InstallOperation* op = &(*ops)[0];
 
   vector<char> data;
-  TEST_AND_RETURN_FALSE(DeltaDiffGenerator::ReadFileToDiff(old_kernel_part,
-                                                           new_kernel_part,
-                                                           std::set<string>(),
-                                                           &data,
-                                                           op,
-                                                           false));
+  TEST_AND_RETURN_FALSE(
+      DeltaDiffGenerator::ReadFileToDiff(old_kernel_part,
+                                         new_kernel_part,
+                                         true, // bsdiff_allowed
+                                         &data,
+                                         op,
+                                         false));
 
   // Write the data
   if (op->type() != DeltaArchiveManifest_InstallOperation_Type_MOVE) {
@@ -494,7 +495,7 @@
 bool DeltaDiffGenerator::ReadFileToDiff(
     const string& old_filename,
     const string& new_filename,
-    const std::set<string>& bsdiff_blacklist,
+    bool bsdiff_allowed,
     vector<char>* out_data,
     DeltaArchiveManifest_InstallOperation* out_op,
     bool gather_extents) {
@@ -540,21 +541,17 @@
       operation.set_type(DeltaArchiveManifest_InstallOperation_Type_MOVE);
       current_best_size = 0;
       data.clear();
-    } else {
-      if (bsdiff_blacklist.find(old_filename) ==
-          bsdiff_blacklist.end()) {
-        // If the source file hasn't been bsdiff blacklisted, then try to see
-        // if bsdiff can find a smaller operation.
-        vector<char> bsdiff_delta;
-        TEST_AND_RETURN_FALSE(
-            BsdiffFiles(old_filename, new_filename, &bsdiff_delta));
-        CHECK_GT(bsdiff_delta.size(), static_cast<vector<char>::size_type>(0));
-        if (bsdiff_delta.size() < current_best_size) {
-          operation.set_type(DeltaArchiveManifest_InstallOperation_Type_BSDIFF);
-          current_best_size = bsdiff_delta.size();
-
-          data = bsdiff_delta;
-        }
+    } else if (bsdiff_allowed) {
+      // If the source file is considered bsdiff safe (no bsdiff bugs
+      // triggered), see if BSDIFF encoding is smaller.
+      vector<char> bsdiff_delta;
+      TEST_AND_RETURN_FALSE(
+          BsdiffFiles(old_filename, new_filename, &bsdiff_delta));
+      CHECK_GT(bsdiff_delta.size(), static_cast<vector<char>::size_type>(0));
+      if (bsdiff_delta.size() < current_best_size) {
+        operation.set_type(DeltaArchiveManifest_InstallOperation_Type_BSDIFF);
+        current_best_size = bsdiff_delta.size();
+        data = bsdiff_delta;
       }
     }
   }
diff --git a/delta_diff_generator.h b/delta_diff_generator.h
index 3997df2..b646545 100644
--- a/delta_diff_generator.h
+++ b/delta_diff_generator.h
@@ -99,7 +99,7 @@
   // Returns true on success.
   static bool ReadFileToDiff(const std::string& old_filename,
                              const std::string& new_filename,
-                             const std::set<std::string>& bsdiff_blacklist,
+                             bool bsdiff_allowed,
                              std::vector<char>* out_data,
                              DeltaArchiveManifest_InstallOperation* out_op,
                              bool gather_extents);
diff --git a/delta_diff_generator_unittest.cc b/delta_diff_generator_unittest.cc
index 632b8e7..1a963da 100644
--- a/delta_diff_generator_unittest.cc
+++ b/delta_diff_generator_unittest.cc
@@ -70,7 +70,7 @@
   DeltaArchiveManifest_InstallOperation op;
   EXPECT_TRUE(DeltaDiffGenerator::ReadFileToDiff(old_path(),
                                                  new_path(),
-                                                 std::set<string>(),
+                                                 true, // bsdiff_allowed
                                                  &data,
                                                  &op,
                                                  true));
@@ -100,7 +100,7 @@
   DeltaArchiveManifest_InstallOperation op;
   EXPECT_TRUE(DeltaDiffGenerator::ReadFileToDiff(old_path(),
                                                  new_path(),
-                                                 std::set<string>(),
+                                                 true, // bsdiff_allowed
                                                  &data,
                                                  &op,
                                                  true));
@@ -119,7 +119,7 @@
   EXPECT_EQ(1, BlocksInExtents(op.dst_extents()));
 }
 
-TEST_F(DeltaDiffGeneratorTest, RunAsRootBsdiffBlacklistNoMatchTest) {
+TEST_F(DeltaDiffGeneratorTest, RunAsRootBsdiffNotAllowedTest) {
   EXPECT_TRUE(utils::WriteFile(old_path().c_str(),
                                reinterpret_cast<const char*>(kRandomString),
                                sizeof(kRandomString) - 1));
@@ -129,48 +129,9 @@
   vector<char> data;
   DeltaArchiveManifest_InstallOperation op;
 
-  std::set<string> bsdiff_blacklist;
-  bsdiff_blacklist.insert("fuzzy_bunny");  // Not the new_path
-
   EXPECT_TRUE(DeltaDiffGenerator::ReadFileToDiff(old_path(),
                                                  new_path(),
-                                                 bsdiff_blacklist,
-                                                 &data,
-                                                 &op,
-                                                 true));
-  EXPECT_FALSE(data.empty());
-
-  EXPECT_TRUE(op.has_type());
-  EXPECT_EQ(DeltaArchiveManifest_InstallOperation_Type_BSDIFF, op.type());
-  EXPECT_FALSE(op.has_data_offset());
-  EXPECT_FALSE(op.has_data_length());
-  EXPECT_EQ(1, op.src_extents_size());
-  EXPECT_EQ(sizeof(kRandomString) - 1, op.src_length());
-  EXPECT_EQ(1, op.dst_extents_size());
-  EXPECT_EQ(sizeof(kRandomString), op.dst_length());
-  EXPECT_EQ(BlocksInExtents(op.src_extents()),
-            BlocksInExtents(op.dst_extents()));
-  EXPECT_EQ(1, BlocksInExtents(op.dst_extents()));
-}
-
-
-TEST_F(DeltaDiffGeneratorTest, RunAsRootBsdiffBlacklistMatchTest) {
-  EXPECT_TRUE(utils::WriteFile(old_path().c_str(),
-                               reinterpret_cast<const char*>(kRandomString),
-                               sizeof(kRandomString) - 1));
-  EXPECT_TRUE(utils::WriteFile(new_path().c_str(),
-                               reinterpret_cast<const char*>(kRandomString),
-                               sizeof(kRandomString)));
-  vector<char> data;
-  DeltaArchiveManifest_InstallOperation op;
-
-  std::set<string> bsdiff_blacklist;
-  bsdiff_blacklist.insert("fuzzy_bunny");
-  bsdiff_blacklist.insert(old_path());
-
-  EXPECT_TRUE(DeltaDiffGenerator::ReadFileToDiff(old_path(),
-                                                 new_path(),
-                                                 bsdiff_blacklist,
+                                                 false, // bsdiff_allowed
                                                  &data,
                                                  &op,
                                                  true));
@@ -182,7 +143,7 @@
   EXPECT_NE(DeltaArchiveManifest_InstallOperation_Type_BSDIFF, op.type());
 }
 
-TEST_F(DeltaDiffGeneratorTest, RunAsRootBsdiffBlacklistMoveMatchTest) {
+TEST_F(DeltaDiffGeneratorTest, RunAsRootBsdiffNotAllowedMoveTest) {
   EXPECT_TRUE(utils::WriteFile(old_path().c_str(),
                                reinterpret_cast<const char*>(kRandomString),
                                sizeof(kRandomString)));
@@ -192,13 +153,9 @@
   vector<char> data;
   DeltaArchiveManifest_InstallOperation op;
 
-  std::set<string> bsdiff_blacklist;
-  bsdiff_blacklist.insert("fuzzy_bunny");
-  bsdiff_blacklist.insert(old_path());
-
   EXPECT_TRUE(DeltaDiffGenerator::ReadFileToDiff(old_path(),
                                                  new_path(),
-                                                 bsdiff_blacklist,
+                                                 false, // bsdiff_allowed
                                                  &data,
                                                  &op,
                                                  true));
@@ -223,7 +180,7 @@
     DeltaArchiveManifest_InstallOperation op;
     EXPECT_TRUE(DeltaDiffGenerator::ReadFileToDiff(old_path(),
                                                    new_path(),
-                                                   std::set<string>(),
+                                                   true, // bsdiff_allowed
                                                    &data,
                                                    &op,
                                                    true));
@@ -255,7 +212,7 @@
   DeltaArchiveManifest_InstallOperation op;
   EXPECT_TRUE(DeltaDiffGenerator::ReadFileToDiff(old_path(),
                                                  new_path(),
-                                                 std::set<string>(),
+                                                 true, // bsdiff_allowed
                                                  &data,
                                                  &op,
                                                  false));