small misspelling fixes.

src/string-search.h

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 296 matching lines @@
 int StringSearch<PatternChar, SubjectChar>::BoyerMooreSearch(
     StringSearch<PatternChar, SubjectChar>* search,
     Vector<const SubjectChar> subject,
     int start_index) {
   Vector<const PatternChar> pattern = search->pattern_;
   int subject_length = subject.length();
   int pattern_length = pattern.length();
   // Only preprocess at most kBMMaxShift last characters of pattern.
   int start = search->start_;
 
-  int* bad_char_occurence = search->bad_char_table();
+  int* bad_char_occurrence = search->bad_char_table();
   int* good_suffix_shift = search->good_suffix_shift_table();
 
   PatternChar last_char = pattern[pattern_length - 1];
   int index = start_index;
   // Continue search from i.
   while (index <= subject_length - pattern_length) {
     int j = pattern_length - 1;
     int c;
     while (last_char != (c = subject[index + j])) {
       int shift =
-          j - CharOccurrence(bad_char_occurence, c);
+          j - CharOccurrence(bad_char_occurrence, c);
       index += shift;
       if (index > subject_length - pattern_length) {
         return -1;
       }
     }
     while (j >= 0 && pattern[j] == (c = subject[index + j])) j--;
     if (j < 0) {
       return index;
     } else if (j < start) {
       // we have matched more than our tables allow us to be smart about.
       // Fall back on BMH shift.
       index += pattern_length - 1
-          - CharOccurrence(bad_char_occurence,
+          - CharOccurrence(bad_char_occurrence,
                            static_cast<SubjectChar>(last_char));
     } else {
       int gs_shift = good_suffix_shift[j + 1];
       int bc_occ =
-          CharOccurrence(bad_char_occurence, c);
+          CharOccurrence(bad_char_occurrence, c);
       int shift = j - bc_occ;
       if (gs_shift > shift) {
         shift = gs_shift;
       }
       index += shift;
     }
   }
 
   return -1;
 }
@@ skipping 214 matching lines @@
                  Vector<const SubjectChar> subject,
                  Vector<const PatternChar> pattern,
                  int start_index) {
   StringSearch<PatternChar, SubjectChar> search(isolate, pattern);
   return search.Search(subject, start_index);
 }
 
 }}  // namespace v8::internal
 
 #endif  // V8_STRING_SEARCH_H_