Error diagnostics for Blacklist IO...

chrome/browser/privacy_blacklist/blacklist.cc

 // Copyright (c) 2009 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/privacy_blacklist/blacklist.h"
 
 #include <algorithm>
+#include <limits>
 #include <string>
 
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/string_util.h"
 #include "chrome/browser/privacy_blacklist/blacklist_store.h"
 #include "chrome/common/url_constants.h"
 #include "net/http/http_util.h"
 
 #define STRINGIZE(s) #s
@@ skipping 134 matching lines @@
     ((attributes_ & kBlockUnsecure) && !url.SchemeIsSecure());
 }
 
 Blacklist::Match::Match() : attributes_(0) {}
 
 void Blacklist::Match::AddEntry(const Entry* entry) {
   attributes_ |= entry->attributes();
   entries_.push_back(entry);
 }
 
-Blacklist::Blacklist(const FilePath& file) {
+Blacklist::Blacklist(const FilePath& file) : is_good_(false) {
   // No blacklist, nothing to load.
   if (file.value().empty())
     return;
 
-  BlacklistStoreInput input(file_util::OpenFile(file, "rb"));
+  FILE* fp = file_util::OpenFile(file, "rb");
+  if (fp == NULL)
+    return;
+
+  BlacklistStoreInput input(fp);
 
   // Read the providers
   std::size_t n = input.ReadNumProviders();
+  if (n == std::numeric_limits<uint32>::max())
+    return;
+
   providers_.reserve(n);
   std::string name;
   std::string url;
   for (std::size_t i = 0; i < n; ++i) {
-    input.ReadProvider(&name, &url);
+    if (!input.ReadProvider(&name, &url))
+      return;
     providers_.push_back(new Provider(name.c_str(), url.c_str()));
   }
 
   // Read the entries
   n = input.ReadNumEntries();
+  if (n == std::numeric_limits<uint32>::max())
+    return;
+
   std::string pattern;
   unsigned int attributes, provider;
   std::vector<std::string> types;
   for (unsigned int i = 0; i < n; ++i) {
-    input.ReadEntry(&pattern, &attributes, &types, &provider);
+    if (!input.ReadEntry(&pattern, &attributes, &types, &provider))
+      return;
+
     Entry* entry = new Entry(pattern, providers_[provider]);
     entry->AddAttributes(attributes);
     entry->SwapTypes(&types);
     blacklist_.push_back(entry);
   }
+
+  is_good_ = true;
 }
 
 Blacklist::~Blacklist() {
   for (std::vector<Entry*>::iterator i = blacklist_.begin();
        i != blacklist_.end(); ++i)
     delete *i;
   for (std::vector<Provider*>::iterator i = providers_.begin();
        i != providers_.end(); ++i)
     delete *i;
 }
 
 // Returns a pointer to the Blacklist-owned entry which matches the given
 // URL. If no matching Entry is found, returns null.
 Blacklist::Match* Blacklist::findMatch(const GURL& url) const {
+  if (!is_good_)
+    return NULL;  // Don't attempt to find matches if the data is corrupt.
+
   // Never match something which is not http, https or ftp.
   // TODO(idanan): Investigate if this would be an inclusion test instead of an
   // exclusion test and if there are other schemes to test for.
   if (!url.SchemeIs(chrome::kHttpScheme) &&
       !url.SchemeIs(chrome::kHttpsScheme) &&
       !url.SchemeIs(chrome::kFtpScheme))
     return 0;
   Match* match = NULL;
   for (std::vector<Entry*>::const_iterator i = blacklist_.begin();
        i != blacklist_.end(); ++i) {
@@ skipping 21 matching lines @@
         return cookie;
 
     std::string session_cookie(cookie, 0, i);
     std::string::size_type end = cookie.find(';', start + 1);
     if (end != std::string::npos)
       session_cookie.append(cookie.substr(end));
     return session_cookie;
   }
   return cookie;
 }